Clover Coverage Report - PMD 5.0.0
Coverage timestamp: Tue May 1 2012 12:30:41 CEST
Overview   Package   File
    FRAMES   NO FRAMES     
../../../../../../img/srcFileCovDistChart7.png 51% of files have more coverage
7,913   9,964   3,148   13.14
2,828   9,193   0.4   200.67
602     5.23  
3    
 
  JavaParser       Line # 7 7,913 0% 3,148 4,175 63.2% 0.6319316
  JavaParser.LookaheadSuccess       Line # 9752 0 - 0 0 - -1.0
  JavaParser.JJCalls       Line # 9957 0 - 0 0 - -1.0
 
  (741)
 
1    /* Generated By:JJTree&JavaCC: Do not edit this line. JavaParser.java */
2    package net.sourceforge.pmd.lang.java.ast;
3    import java.util.*;
4    import net.sourceforge.pmd.PMD;
5    import net.sourceforge.pmd.lang.ast.CharStream;
6    import net.sourceforge.pmd.lang.ast.TokenMgrError;
 
7    public class JavaParser/*@bgen(jjtree)*/implements JavaParserTreeConstants, JavaParserConstants {/*@bgen(jjtree)*/
8    protected JJTJavaParserState jjtree = new JJTJavaParserState();
9    private int jdkVersion = 0;
10   
 
11  8947 toggle public void setJdkVersion(int jdkVersion) {
12  8948 this.jdkVersion = jdkVersion;
13    }
14   
 
15  88033 toggle private void checkForBadAssertUsage(String in, String usage) {
16  88038 if (jdkVersion > 3 && in.equals("assert")) {
17  6 throw new ParseException("Can't use 'assert' as " + usage + " when running in JDK 1.4 mode!");
18    }
19    }
20   
 
21  735 toggle private void checkForBadStaticImportUsage() {
22  735 if (jdkVersion < 5) {
23  3 throw new ParseException("Can't use static imports when running in JDK 1.4 mode!");
24    }
25    }
26   
 
27  4822 toggle private void checkForBadAnnotationUsage() {
28  4824 if (jdkVersion < 5) {
29  3 throw new ParseException("Can't use annotations when running in JDK 1.4 mode!");
30    }
31    }
32   
 
33  8391 toggle private void checkForBadGenericsUsage() {
34  8391 if (jdkVersion < 5) {
35  0 throw new ParseException("Can't use generics unless running in JDK 1.5 mode!");
36    }
37    }
38   
 
39  102 toggle private void checkForBadVariableArgumentsUsage() {
40  102 if (jdkVersion < 5) {
41  3 throw new ParseException("Can't use variable arguments (varargs) when running in JDK 1.4 mode!");
42    }
43    }
44   
 
45  1629 toggle private void checkForBadJDK15ForLoopSyntaxArgumentsUsage() {
46  1629 if (jdkVersion < 5) {
47  3 throw new ParseException("Can't use JDK 1.5 for loop syntax when running in JDK 1.4 mode!");
48    }
49    }
50   
 
51  88021 toggle private void checkForBadEnumUsage(String in, String usage) {
52  88029 if (jdkVersion >= 5 && in.equals("enum")) {
53  6 throw new ParseException("Can't use 'enum' as " + usage + " when running in JDK 1.5 mode!");
54    }
55    }
56   
 
57  225 toggle private void checkForBadHexFloatingPointLiteral() {
58  225 if (jdkVersion < 5) {
59  0 throw new ParseException("Can't use hexadecimal floating point literals in pre-JDK 1.5 target");
60    }
61    }
62   
 
63  47359 toggle private void checkForBadNumericalLiteralslUsage(Token token) {
64  47358 if (jdkVersion < 7) {
65  46471 if (token.image.contains("_")) {
66  0 throw new ParseException("Can't use underscores in numerical literals when running in JDK inferior to 1.7 mode!");
67    }
68   
69  46473 if (token.image.startsWith("0b") || token.image.startsWith("0B")) {
70  0 throw new ParseException("Can't use binary numerical literals when running in JDK inferior to 1.7 mode!");
71    }
72    }
73    }
74   
 
75  3 toggle private void checkForBadDiamondUsage() {
76  3 if (jdkVersion < 7) {
77  0 throw new ParseException("Cannot use the diamond generic notation when running in JDK inferior to 1.7 mode!");
78    }
79    }
80   
 
81  12 toggle private void checkForBadTryWithResourcesUsage() {
82  12 if (jdkVersion < 7) {
83  0 throw new ParseException("Cannot use the try-with-resources notation when running in JDK inferior to 1.7 mode!");
84    }
85    }
86   
87    // This is a semantic LOOKAHEAD to determine if we're dealing with an assert
88    // Note that this can't be replaced with a syntactic lookahead
89    // since "assert" isn't a string literal token
 
90  642567 toggle private boolean isNextTokenAnAssert() {
91  642625 boolean res = getToken(1).image.equals("assert");
92  642640 if (res && jdkVersion <= 3 && getToken(2).image.equals("(")) {
93  24 res = false;
94    }
95  642669 return res;
96    }
97   
 
98  54283 toggle private boolean isPrecededByComment(Token tok) {
99  54284 boolean res = false;
100  345966 while (!res && tok.specialToken != null) {
101  291675 tok = tok.specialToken;
102  291681 res = tok.kind == SINGLE_LINE_COMMENT ||
103    tok.kind == FORMAL_COMMENT ||
104    tok.kind == MULTI_LINE_COMMENT;
105    }
106  54293 return res;
107    }
108   
 
109  8306 toggle public Map<Integer, String> getSuppressMap() {
110  8307 return token_source.getSuppressMap();
111    }
112   
 
113  8304 toggle public void setSuppressMarker(String marker) {
114  8306 token_source.setSuppressMarker(marker);
115    }
116   
117    /*****************************************
118    * THE JAVA LANGUAGE GRAMMAR STARTS HERE *
119    *****************************************/
120   
121    /*
122    * Program structuring syntax follows.
123    */
 
124  8948 toggle final public ASTCompilationUnit CompilationUnit() throws ParseException {
125    /*@bgen(jjtree) CompilationUnit */
126  8949 ASTCompilationUnit jjtn000 = new ASTCompilationUnit(this, JJTCOMPILATIONUNIT);
127  8949 boolean jjtc000 = true;
128  8949 jjtree.openNodeScope(jjtn000);
129  8948 try {
130  8949 if (jj_2_1(2147483647)) {
131  3117 PackageDeclaration();
132    } else {
133  5832 ;
134    }
135  8946 label_1:
136    while (true) {
137  28245 switch (jj_nt.kind) {
138  19302 case IMPORT:
139  19302 ;
140  19302 break;
141  8946 default:
142  8946 jj_la1[0] = jj_gen;
143  8945 break label_1;
144    }
145  19300 ImportDeclaration();
146    }
147  8945 label_2:
148    while (true) {
149  17928 switch (jj_nt.kind) {
150  3 case ABSTRACT:
151  144 case CLASS:
152  3 case FINAL:
153  15 case INTERFACE:
154  0 case NATIVE:
155  0 case PRIVATE:
156  0 case PROTECTED:
157  8749 case PUBLIC:
158  0 case STATIC:
159  0 case SYNCHRONIZED:
160  0 case TRANSIENT:
161  0 case VOLATILE:
162  3 case STRICTFP:
163  0 case IDENTIFIER:
164  9 case SEMICOLON:
165  81 case AT:
166  9006 ;
167  9007 break;
168  8921 default:
169  8922 jj_la1[1] = jj_gen;
170  8920 break label_2;
171    }
172  9008 TypeDeclaration();
173    }
174  8922 switch (jj_nt.kind) {
175  0 case 124:
176  0 jj_consume_token(124);
177  0 break;
178  8922 default:
179  8921 jj_la1[2] = jj_gen;
180  8922 ;
181    }
182  8922 switch (jj_nt.kind) {
183  0 case 125:
184  0 jj_consume_token(125);
185  0 break;
186  8922 default:
187  8922 jj_la1[3] = jj_gen;
188  8922 ;
189    }
190  8920 jj_consume_token(0);
191  8922 jjtree.closeNodeScope(jjtn000, true);
192  8922 jjtc000 = false;
193  8920 jjtn000.setComments(token_source.comments);
194  8922 {if (true) return jjtn000;}
195    } catch (Throwable jjte000) {
196  27 if (jjtc000) {
197  27 jjtree.clearNodeScope(jjtn000);
198  27 jjtc000 = false;
199    } else {
200  0 jjtree.popNode();
201    }
202  27 if (jjte000 instanceof RuntimeException) {
203  27 {if (true) throw (RuntimeException)jjte000;}
204    }
205  0 if (jjte000 instanceof ParseException) {
206  0 {if (true) throw (ParseException)jjte000;}
207    }
208  0 {if (true) throw (Error)jjte000;}
209    } finally {
210  8948 if (jjtc000) {
211  0 jjtree.closeNodeScope(jjtn000, true);
212    }
213    }
214  0 throw new RuntimeException("Missing return statement in function");
215    }
216   
 
217  3115 toggle final public void PackageDeclaration() throws ParseException {
218    /*@bgen(jjtree) PackageDeclaration */
219  3116 ASTPackageDeclaration jjtn000 = new ASTPackageDeclaration(this, JJTPACKAGEDECLARATION);
220  3117 boolean jjtc000 = true;
221  3116 jjtree.openNodeScope(jjtn000);
222  3117 try {
223  3117 label_3:
224    while (true) {
225  3126 switch (jj_nt.kind) {
226  9 case AT:
227  9 ;
228  9 break;
229  3117 default:
230  3117 jj_la1[4] = jj_gen;
231  3116 break label_3;
232    }
233  9 Annotation();
234    }
235  3116 jj_consume_token(PACKAGE);
236  3117 Name();
237  3115 jj_consume_token(SEMICOLON);
238    } catch (Throwable jjte000) {
239  0 if (jjtc000) {
240  0 jjtree.clearNodeScope(jjtn000);
241  0 jjtc000 = false;
242    } else {
243  0 jjtree.popNode();
244    }
245  0 if (jjte000 instanceof RuntimeException) {
246  0 {if (true) throw (RuntimeException)jjte000;}
247    }
248  0 if (jjte000 instanceof ParseException) {
249  0 {if (true) throw (ParseException)jjte000;}
250    }
251  0 {if (true) throw (Error)jjte000;}
252    } finally {
253  3117 if (jjtc000) {
254  3117 jjtree.closeNodeScope(jjtn000, true);
255    }
256    }
257    }
258   
 
259  19301 toggle final public void ImportDeclaration() throws ParseException {
260    /*@bgen(jjtree) ImportDeclaration */
261  19302 ASTImportDeclaration jjtn000 = new ASTImportDeclaration(this, JJTIMPORTDECLARATION);
262  19302 boolean jjtc000 = true;
263  19301 jjtree.openNodeScope(jjtn000);
264  19302 try {
265  19302 jj_consume_token(IMPORT);
266  19302 switch (jj_nt.kind) {
267  735 case STATIC:
268  735 jj_consume_token(STATIC);
269  732 checkForBadStaticImportUsage();jjtn000.setStatic();
270  732 break;
271  18567 default:
272  18567 jj_la1[5] = jj_gen;
273  18566 ;
274    }
275  19299 Name();
276  19299 switch (jj_nt.kind) {
277  279 case DOT:
278  279 jj_consume_token(DOT);
279  279 jj_consume_token(STAR);
280  279 jjtn000.setImportOnDemand();
281  279 break;
282  19020 default:
283  19020 jj_la1[6] = jj_gen;
284  19020 ;
285    }
286  19298 jj_consume_token(SEMICOLON);
287    } catch (Throwable jjte000) {
288  3 if (jjtc000) {
289  3 jjtree.clearNodeScope(jjtn000);
290  3 jjtc000 = false;
291    } else {
292  0 jjtree.popNode();
293    }
294  3 if (jjte000 instanceof RuntimeException) {
295  3 {if (true) throw (RuntimeException)jjte000;}
296    }
297  0 if (jjte000 instanceof ParseException) {
298  0 {if (true) throw (ParseException)jjte000;}
299    }
300  0 {if (true) throw (Error)jjte000;}
301    } finally {
302  19302 if (jjtc000) {
303  19299 jjtree.closeNodeScope(jjtn000, true);
304    }
305    }
306    }
307   
308    /*
309    * Modifiers. We match all modifiers in a single rule to reduce the chances of
310    * syntax errors for simple modifier mistakes. It will also enable us to give
311    * better error messages.
312    */
 
313  54961 toggle final public int Modifiers() throws ParseException {
314  54972 int modifiers = 0;
315  54971 label_4:
316    while (true) {
317  117543 if (jj_2_2(2)) {
318  62569 ;
319    } else {
320  54974 break label_4;
321    }
322  62570 switch (jj_nt.kind) {
323  32158 case PUBLIC:
324  32155 jj_consume_token(PUBLIC);
325  32156 modifiers |= AccessNode.PUBLIC;
326  32158 break;
327  6921 case STATIC:
328  6921 jj_consume_token(STATIC);
329  6921 modifiers |= AccessNode.STATIC;
330  6920 break;
331  1452 case PROTECTED:
332  1452 jj_consume_token(PROTECTED);
333  1452 modifiers |= AccessNode.PROTECTED;
334  1452 break;
335  10720 case PRIVATE:
336  10722 jj_consume_token(PRIVATE);
337  10721 modifiers |= AccessNode.PRIVATE;
338  10721 break;
339  6045 case FINAL:
340  6045 jj_consume_token(FINAL);
341  6044 modifiers |= AccessNode.FINAL;
342  6045 break;
343  435 case ABSTRACT:
344  435 jj_consume_token(ABSTRACT);
345  435 modifiers |= AccessNode.ABSTRACT;
346  435 break;
347  36 case SYNCHRONIZED:
348  36 jj_consume_token(SYNCHRONIZED);
349  36 modifiers |= AccessNode.SYNCHRONIZED;
350  36 break;
351  18 case NATIVE:
352  18 jj_consume_token(NATIVE);
353  18 modifiers |= AccessNode.NATIVE;
354  18 break;
355  6 case TRANSIENT:
356  6 jj_consume_token(TRANSIENT);
357  6 modifiers |= AccessNode.TRANSIENT;
358  6 break;
359  12 case VOLATILE:
360  12 jj_consume_token(VOLATILE);
361  12 modifiers |= AccessNode.VOLATILE;
362  12 break;
363  6 case STRICTFP:
364  6 jj_consume_token(STRICTFP);
365  6 modifiers |= AccessNode.STRICTFP;
366  6 break;
367  4757 case AT:
368  4758 Annotation();
369  4756 break;
370  0 default:
371  0 jj_la1[7] = jj_gen;
372  0 jj_consume_token(-1);
373  0 throw new ParseException();
374    }
375    }
376  54973 {if (true) return modifiers;}
377  0 throw new RuntimeException("Missing return statement in function");
378    }
379   
380    /*
381    * Declaration syntax follows.
382    */
 
383  9006 toggle final public void TypeDeclaration() throws ParseException {
384    /*@bgen(jjtree) TypeDeclaration */
385  9007 ASTTypeDeclaration jjtn000 = new ASTTypeDeclaration(this, JJTTYPEDECLARATION);
386  9009 boolean jjtc000 = true;
387  9009 jjtree.openNodeScope(jjtn000);int modifiers;
388  9009 try {
389  9009 switch (jj_nt.kind) {
390  9 case SEMICOLON:
391  9 jj_consume_token(SEMICOLON);
392  9 break;
393  3 case ABSTRACT:
394  144 case CLASS:
395  3 case FINAL:
396  15 case INTERFACE:
397  0 case NATIVE:
398  0 case PRIVATE:
399  0 case PROTECTED:
400  8749 case PUBLIC:
401  0 case STATIC:
402  0 case SYNCHRONIZED:
403  0 case TRANSIENT:
404  0 case VOLATILE:
405  3 case STRICTFP:
406  0 case IDENTIFIER:
407  81 case AT:
408  8997 modifiers = Modifiers();
409  8999 switch (jj_nt.kind) {
410  0 case ABSTRACT:
411  8598 case CLASS:
412  0 case FINAL:
413  354 case INTERFACE:
414  8951 ClassOrInterfaceDeclaration(modifiers);
415  8926 break;
416  30 case IDENTIFIER:
417  30 EnumDeclaration(modifiers);
418  30 break;
419  18 case AT:
420  18 AnnotationTypeDeclaration(modifiers);
421  18 break;
422  0 default:
423  0 jj_la1[8] = jj_gen;
424  0 jj_consume_token(-1);
425  0 throw new ParseException();
426    }
427  8975 break;
428  0 default:
429  0 jj_la1[9] = jj_gen;
430  0 jj_consume_token(-1);
431  0 throw new ParseException();
432    }
433    } catch (Throwable jjte000) {
434  24 if (jjtc000) {
435  24 jjtree.clearNodeScope(jjtn000);
436  24 jjtc000 = false;
437    } else {
438  0 jjtree.popNode();
439    }
440  24 if (jjte000 instanceof RuntimeException) {
441  24 {if (true) throw (RuntimeException)jjte000;}
442    }
443  0 if (jjte000 instanceof ParseException) {
444  0 {if (true) throw (ParseException)jjte000;}
445    }
446  0 {if (true) throw (Error)jjte000;}
447    } finally {
448  9007 if (jjtc000) {
449  8985 jjtree.closeNodeScope(jjtn000, true);
450    }
451    }
452    }
453   
 
454  9532 toggle final public void ClassOrInterfaceDeclaration(int modifiers) throws ParseException {
455    /*@bgen(jjtree) ClassOrInterfaceDeclaration */
456  9533 ASTClassOrInterfaceDeclaration jjtn000 = new ASTClassOrInterfaceDeclaration(this, JJTCLASSORINTERFACEDECLARATION);
457  9533 boolean jjtc000 = true;
458  9534 jjtree.openNodeScope(jjtn000);Token t = null;
459  9534 jjtn000.setModifiers(modifiers);
460  9534 try {
461  9533 switch (jj_nt.kind) {
462  3 case ABSTRACT:
463  9123 case CLASS:
464  6 case FINAL:
465  9132 switch (jj_nt.kind) {
466  3 case ABSTRACT:
467  6 case FINAL:
468  9 switch (jj_nt.kind) {
469  6 case FINAL:
470  6 jj_consume_token(FINAL);
471  6 break;
472  3 case ABSTRACT:
473  3 jj_consume_token(ABSTRACT);
474  3 break;
475  0 default:
476  0 jj_la1[10] = jj_gen;
477  0 jj_consume_token(-1);
478  0 throw new ParseException();
479    }
480  9 break;
481  9122 default:
482  9123 jj_la1[11] = jj_gen;
483  9123 ;
484    }
485  9131 jj_consume_token(CLASS);
486  9132 break;
487  402 case INTERFACE:
488  402 jj_consume_token(INTERFACE);
489  402 jjtn000.setInterface();
490  402 break;
491  0 default:
492  0 jj_la1[12] = jj_gen;
493  0 jj_consume_token(-1);
494  0 throw new ParseException();
495    }
496  9534 t = jj_consume_token(IDENTIFIER);
497  9534 jjtn000.setImage(t.image);
498  9534 switch (jj_nt.kind) {
499  123 case LT:
500  123 TypeParameters();
501  123 break;
502  9411 default:
503  9411 jj_la1[13] = jj_gen;
504  9411 ;
505    }
506  9534 switch (jj_nt.kind) {
507  2562 case EXTENDS:
508  2562 ExtendsList();
509  2561 break;
510  6972 default:
511  6972 jj_la1[14] = jj_gen;
512  6972 ;
513    }
514  9533 switch (jj_nt.kind) {
515  558 case IMPLEMENTS:
516  558 ImplementsList();
517  558 break;
518  8976 default:
519  8976 jj_la1[15] = jj_gen;
520  8976 ;
521    }
522  9534 ClassOrInterfaceBody();
523    } catch (Throwable jjte000) {
524  24 if (jjtc000) {
525  24 jjtree.clearNodeScope(jjtn000);
526  24 jjtc000 = false;
527    } else {
528  0 jjtree.popNode();
529    }
530  24 if (jjte000 instanceof RuntimeException) {
531  24 {if (true) throw (RuntimeException)jjte000;}
532    }
533  0 if (jjte000 instanceof ParseException) {
534  0 {if (true) throw (ParseException)jjte000;}
535    }
536  0 {if (true) throw (Error)jjte000;}
537    } finally {
538  9533 if (jjtc000) {
539  9508 jjtree.closeNodeScope(jjtn000, true);
540    }
541    }
542    }
543   
 
544  2562 toggle final public void ExtendsList() throws ParseException {
545    /*@bgen(jjtree) ExtendsList */
546  2562 ASTExtendsList jjtn000 = new ASTExtendsList(this, JJTEXTENDSLIST);
547  2562 boolean jjtc000 = true;
548  2562 jjtree.openNodeScope(jjtn000);boolean extendsMoreThanOne = false;
549  2562 try {
550  2562 jj_consume_token(EXTENDS);
551  2562 ClassOrInterfaceType();
552  2561 label_5:
553    while (true) {
554  2565 switch (jj_nt.kind) {
555  3 case COMMA:
556  3 ;
557  3 break;
558  2562 default:
559  2562 jj_la1[16] = jj_gen;
560  2562 break label_5;
561    }
562  3 jj_consume_token(COMMA);
563  3 ClassOrInterfaceType();
564  3 extendsMoreThanOne = true;
565    }
566    } catch (Throwable jjte000) {
567  0 if (jjtc000) {
568  0 jjtree.clearNodeScope(jjtn000);
569  0 jjtc000 = false;
570    } else {
571  0 jjtree.popNode();
572    }
573  0 if (jjte000 instanceof RuntimeException) {
574  0 {if (true) throw (RuntimeException)jjte000;}
575    }
576  0 if (jjte000 instanceof ParseException) {
577  0 {if (true) throw (ParseException)jjte000;}
578    }
579  0 {if (true) throw (Error)jjte000;}
580    } finally {
581  2562 if (jjtc000) {
582  2561 jjtree.closeNodeScope(jjtn000, true);
583    }
584    }
585    }
586   
 
587  558 toggle final public void ImplementsList() throws ParseException {
588    /*@bgen(jjtree) ImplementsList */
589  558 ASTImplementsList jjtn000 = new ASTImplementsList(this, JJTIMPLEMENTSLIST);
590  558 boolean jjtc000 = true;
591  558 jjtree.openNodeScope(jjtn000);
592  558 try {
593  558 jj_consume_token(IMPLEMENTS);
594  558 ClassOrInterfaceType();
595  558 label_6:
596    while (true) {
597  594 switch (jj_nt.kind) {
598  36 case COMMA:
599  36 ;
600  36 break;
601  558 default:
602  558 jj_la1[17] = jj_gen;
603  558 break label_6;
604    }
605  36 jj_consume_token(COMMA);
606  36 ClassOrInterfaceType();
607    }
608    } catch (Throwable jjte000) {
609  0 if (jjtc000) {
610  0 jjtree.clearNodeScope(jjtn000);
611  0 jjtc000 = false;
612    } else {
613  0 jjtree.popNode();
614    }
615  0 if (jjte000 instanceof RuntimeException) {
616  0 {if (true) throw (RuntimeException)jjte000;}
617    }
618  0 if (jjte000 instanceof ParseException) {
619  0 {if (true) throw (ParseException)jjte000;}
620    }
621  0 {if (true) throw (Error)jjte000;}
622    } finally {
623  558 if (jjtc000) {
624  558 jjtree.closeNodeScope(jjtn000, true);
625    }
626    }
627    }
628   
 
629  48 toggle final public void EnumDeclaration(int modifiers) throws ParseException {
630    /*@bgen(jjtree) EnumDeclaration */
631  48 ASTEnumDeclaration jjtn000 = new ASTEnumDeclaration(this, JJTENUMDECLARATION);
632  48 boolean jjtc000 = true;
633  48 jjtree.openNodeScope(jjtn000);Token t;
634  48 jjtn000.setModifiers(modifiers);
635  48 try {
636  48 t = jj_consume_token(IDENTIFIER);
637  48 if (!t.image.equals("enum")) {
638  0 {if (true) throw new ParseException("ERROR: expecting enum");}
639    }
640   
641  48 if (jdkVersion < 5) {
642  0 {if (true) throw new ParseException("ERROR: Can't use enum as a keyword in pre-JDK 1.5 target");}
643    }
644  48 t = jj_consume_token(IDENTIFIER);
645  48 jjtn000.setImage(t.image);
646  48 switch (jj_nt.kind) {
647  0 case IMPLEMENTS:
648  0 ImplementsList();
649  0 break;
650  48 default:
651  48 jj_la1[18] = jj_gen;
652  48 ;
653    }
654  48 EnumBody();
655    } catch (Throwable jjte000) {
656  0 if (jjtc000) {
657  0 jjtree.clearNodeScope(jjtn000);
658  0 jjtc000 = false;
659    } else {
660  0 jjtree.popNode();
661    }
662  0 if (jjte000 instanceof RuntimeException) {
663  0 {if (true) throw (RuntimeException)jjte000;}
664    }
665  0 if (jjte000 instanceof ParseException) {
666  0 {if (true) throw (ParseException)jjte000;}
667    }
668  0 {if (true) throw (Error)jjte000;}
669    } finally {
670  48 if (jjtc000) {
671  48 jjtree.closeNodeScope(jjtn000, true);
672    }
673    }
674    }
675   
 
676  48 toggle final public void EnumBody() throws ParseException {
677    /*@bgen(jjtree) EnumBody */
678  48 ASTEnumBody jjtn000 = new ASTEnumBody(this, JJTENUMBODY);
679  48 boolean jjtc000 = true;
680  48 jjtree.openNodeScope(jjtn000);
681  48 try {
682  48 jj_consume_token(LBRACE);
683  48 switch (jj_nt.kind) {
684  45 case IDENTIFIER:
685  0 case AT:
686  45 label_7:
687    while (true) {
688  45 switch (jj_nt.kind) {
689  0 case AT:
690  0 ;
691  0 break;
692  45 default:
693  45 jj_la1[19] = jj_gen;
694  45 break label_7;
695    }
696  0 Annotation();
697    }
698  45 EnumConstant();
699  45 label_8:
700    while (true) {
701  225 if (jj_2_3(2)) {
702  180 ;
703    } else {
704  45 break label_8;
705    }
706  180 jj_consume_token(COMMA);
707  180 label_9:
708    while (true) {
709  180 switch (jj_nt.kind) {
710  0 case AT:
711  0 ;
712  0 break;
713  180 default:
714  180 jj_la1[20] = jj_gen;
715  180 break label_9;
716    }
717  0 Annotation();
718    }
719  180 EnumConstant();
720    }
721  45 break;
722  3 default:
723  3 jj_la1[21] = jj_gen;
724  3 ;
725    }
726  48 switch (jj_nt.kind) {
727  0 case COMMA:
728  0 jj_consume_token(COMMA);
729  0 break;
730  48 default:
731  48 jj_la1[22] = jj_gen;
732  48 ;
733    }
734  48 switch (jj_nt.kind) {
735  39 case SEMICOLON:
736  39 jj_consume_token(SEMICOLON);
737  39 label_10:
738    while (true) {
739  243 switch (jj_nt.kind) {
740  0 case ABSTRACT:
741  0 case BOOLEAN:
742  0 case BYTE:
743  0 case CHAR:
744  0 case CLASS:
745  0 case DOUBLE:
746  0 case FINAL:
747  0 case FLOAT:
748  0 case INT:
749  0 case INTERFACE:
750  0 case LONG:
751  0 case NATIVE:
752  75 case PRIVATE:
753  0 case PROTECTED:
754  111 case PUBLIC:
755  0 case SHORT:
756  0 case STATIC:
757  0 case SYNCHRONIZED:
758  0 case TRANSIENT:
759  0 case VOID:
760  0 case VOLATILE:
761  0 case STRICTFP:
762  9 case IDENTIFIER:
763  0 case LBRACE:
764  0 case SEMICOLON:
765  9 case AT:
766  0 case LT:
767  204 ;
768  204 break;
769  39 default:
770  39 jj_la1[23] = jj_gen;
771  39 break label_10;
772    }
773  204 ClassOrInterfaceBodyDeclaration();
774    }
775  39 break;
776  9 default:
777  9 jj_la1[24] = jj_gen;
778  9 ;
779    }
780  48 jj_consume_token(RBRACE);
781    } catch (Throwable jjte000) {
782  0 if (jjtc000) {
783  0 jjtree.clearNodeScope(jjtn000);
784  0 jjtc000 = false;
785    } else {
786  0 jjtree.popNode();
787    }
788  0 if (jjte000 instanceof RuntimeException) {
789  0 {if (true) throw (RuntimeException)jjte000;}
790    }
791  0 if (jjte000 instanceof ParseException) {
792  0 {if (true) throw (ParseException)jjte000;}
793    }
794  0 {if (true) throw (Error)jjte000;}
795    } finally {
796  48 if (jjtc000) {
797  48 jjtree.closeNodeScope(jjtn000, true);
798    }
799    }
800    }
801   
 
802  225 toggle final public void EnumConstant() throws ParseException {
803    /*@bgen(jjtree) EnumConstant */
804  225 ASTEnumConstant jjtn000 = new ASTEnumConstant(this, JJTENUMCONSTANT);
805  225 boolean jjtc000 = true;
806  225 jjtree.openNodeScope(jjtn000);Token t;
807  225 try {
808  225 t = jj_consume_token(IDENTIFIER);
809  225 jjtn000.setImage(t.image);
810  225 switch (jj_nt.kind) {
811  186 case LPAREN:
812  186 Arguments();
813  186 break;
814  39 default:
815  39 jj_la1[25] = jj_gen;
816  39 ;
817    }
818  225 switch (jj_nt.kind) {
819  6 case LBRACE:
820  6 ClassOrInterfaceBody();
821  6 break;
822  219 default:
823  219 jj_la1[26] = jj_gen;
824  219 ;
825    }
826    } catch (Throwable jjte000) {
827  0 if (jjtc000) {
828  0 jjtree.clearNodeScope(jjtn000);
829  0 jjtc000 = false;
830    } else {
831  0 jjtree.popNode();
832    }
833  0 if (jjte000 instanceof RuntimeException) {
834  0 {if (true) throw (RuntimeException)jjte000;}
835    }
836  0 if (jjte000 instanceof ParseException) {
837  0 {if (true) throw (ParseException)jjte000;}
838    }
839  0 {if (true) throw (Error)jjte000;}
840    } finally {
841  225 if (jjtc000) {
842  225 jjtree.closeNodeScope(jjtn000, true);
843    }
844    }
845    }
846   
 
847  288 toggle final public void TypeParameters() throws ParseException {
848    /*@bgen(jjtree) TypeParameters */
849  288 ASTTypeParameters jjtn000 = new ASTTypeParameters(this, JJTTYPEPARAMETERS);
850  288 boolean jjtc000 = true;
851  288 jjtree.openNodeScope(jjtn000);
852  288 try {
853  288 jj_consume_token(LT);
854  288 checkForBadGenericsUsage();
855  288 TypeParameter();
856  288 label_11:
857    while (true) {
858  309 switch (jj_nt.kind) {
859  21 case COMMA:
860  21 ;
861  21 break;
862  288 default:
863  288 jj_la1[27] = jj_gen;
864  288 break label_11;
865    }
866  21 jj_consume_token(COMMA);
867  21 TypeParameter();
868    }
869  288 jj_consume_token(GT);
870    } catch (Throwable jjte000) {
871  0 if (jjtc000) {
872  0 jjtree.clearNodeScope(jjtn000);
873  0 jjtc000 = false;
874    } else {
875  0 jjtree.popNode();
876    }
877  0 if (jjte000 instanceof RuntimeException) {
878  0 {if (true) throw (RuntimeException)jjte000;}
879    }
880  0 if (jjte000 instanceof ParseException) {
881  0 {if (true) throw (ParseException)jjte000;}
882    }
883  0 {if (true) throw (Error)jjte000;}
884    } finally {
885  288 if (jjtc000) {
886  288 jjtree.closeNodeScope(jjtn000, true);
887    }
888    }
889    }
890   
 
891  309 toggle final public void TypeParameter() throws ParseException {
892    /*@bgen(jjtree) TypeParameter */
893  309 ASTTypeParameter jjtn000 = new ASTTypeParameter(this, JJTTYPEPARAMETER);
894  309 boolean jjtc000 = true;
895  309 jjtree.openNodeScope(jjtn000);Token t;
896  309 try {
897  309 t = jj_consume_token(IDENTIFIER);
898  309 jjtn000.setImage(t.image);
899  309 switch (jj_nt.kind) {
900  66 case EXTENDS:
901  66 TypeBound();
902  66 break;
903  243 default:
904  243 jj_la1[28] = jj_gen;
905  243 ;
906    }
907    } catch (Throwable jjte000) {
908  0 if (jjtc000) {
909  0 jjtree.clearNodeScope(jjtn000);
910  0 jjtc000 = false;
911    } else {
912  0 jjtree.popNode();
913    }
914  0 if (jjte000 instanceof RuntimeException) {
915  0 {if (true) throw (RuntimeException)jjte000;}
916    }
917  0 if (jjte000 instanceof ParseException) {
918  0 {if (true) throw (ParseException)jjte000;}
919    }
920  0 {if (true) throw (Error)jjte000;}
921    } finally {
922  309 if (jjtc000) {
923  309 jjtree.closeNodeScope(jjtn000, true);
924    }
925    }
926    }
927   
 
928  66 toggle final public void TypeBound() throws ParseException {
929    /*@bgen(jjtree) TypeBound */
930  66 ASTTypeBound jjtn000 = new ASTTypeBound(this, JJTTYPEBOUND);
931  66 boolean jjtc000 = true;
932  66 jjtree.openNodeScope(jjtn000);
933  66 try {
934  66 jj_consume_token(EXTENDS);
935  66 ClassOrInterfaceType();
936  66 label_12:
937    while (true) {
938  66 switch (jj_nt.kind) {
939  0 case BIT_AND:
940  0 ;
941  0 break;
942  66 default:
943  66 jj_la1[29] = jj_gen;
944  66 break label_12;
945    }
946  0 jj_consume_token(BIT_AND);
947  0 ClassOrInterfaceType();
948    }
949    } catch (Throwable jjte000) {
950  0 if (jjtc000) {
951  0 jjtree.clearNodeScope(jjtn000);
952  0 jjtc000 = false;
953    } else {
954  0 jjtree.popNode();
955    }
956  0 if (jjte000 instanceof RuntimeException) {
957  0 {if (true) throw (RuntimeException)jjte000;}
958    }
959  0 if (jjte000 instanceof ParseException) {
960  0 {if (true) throw (ParseException)jjte000;}
961    }
962  0 {if (true) throw (Error)jjte000;}
963    } finally {
964  66 if (jjtc000) {
965  66 jjtree.closeNodeScope(jjtn000, true);
966    }
967    }
968    }
969   
 
970  9961 toggle final public void ClassOrInterfaceBody() throws ParseException {
971    /*@bgen(jjtree) ClassOrInterfaceBody */
972  9962 ASTClassOrInterfaceBody jjtn000 = new ASTClassOrInterfaceBody(this, JJTCLASSORINTERFACEBODY);
973  9963 boolean jjtc000 = true;
974  9963 jjtree.openNodeScope(jjtn000);
975  9962 try {
976  9962 jj_consume_token(LBRACE);
977  9963 label_13:
978    while (true) {
979  54325 switch (jj_nt.kind) {
980  21 case ABSTRACT:
981  222 case BOOLEAN:
982  72 case BYTE:
983  105 case CHAR:
984  42 case CLASS:
985  198 case DOUBLE:
986  1218 case FINAL:
987  180 case FLOAT:
988  1896 case INT:
989  15 case INTERFACE:
990  135 case LONG:
991  3 case NATIVE:
992  10545 case PRIVATE:
993  1254 case PROTECTED:
994  18561 case PUBLIC:
995  72 case SHORT:
996  1923 case STATIC:
997  9 case SYNCHRONIZED:
998  0 case TRANSIENT:
999  1701 case VOID:
1000  3 case VOLATILE:
1001  0 case STRICTFP:
1002  1560 case IDENTIFIER:
1003  27 case LBRACE:
1004  129 case SEMICOLON:
1005  4470 case AT:
1006  30 case LT:
1007  44391 ;
1008  44394 break;
1009  9937 default:
1010  9938 jj_la1[30] = jj_gen;
1011  9938 break label_13;
1012    }
1013  44393 ClassOrInterfaceBodyDeclaration();
1014    }
1015  9939 jj_consume_token(RBRACE);
1016    } catch (Throwable jjte000) {
1017  24 if (jjtc000) {
1018  24 jjtree.clearNodeScope(jjtn000);
1019  24 jjtc000 = false;
1020    } else {
1021  0 jjtree.popNode();
1022    }
1023  24 if (jjte000 instanceof RuntimeException) {
1024  24 {if (true) throw (RuntimeException)jjte000;}
1025    }
1026  0 if (jjte000 instanceof ParseException) {
1027  0 {if (true) throw (ParseException)jjte000;}
1028    }
1029  0 {if (true) throw (Error)jjte000;}
1030    } finally {
1031  9963 if (jjtc000) {
1032  9937 jjtree.closeNodeScope(jjtn000, true);
1033    }
1034    }
1035    }
1036   
 
1037  44595 toggle final public void ClassOrInterfaceBodyDeclaration() throws ParseException {
1038    /*@bgen(jjtree) ClassOrInterfaceBodyDeclaration */
1039  44601 ASTClassOrInterfaceBodyDeclaration jjtn000 = new ASTClassOrInterfaceBodyDeclaration(this, JJTCLASSORINTERFACEBODYDECLARATION);
1040  44599 boolean jjtc000 = true;
1041  44600 jjtree.openNodeScope(jjtn000);int modifiers;
1042  44596 try {
1043  44599 if (jj_2_8(2147483647)) {
1044  126 Initializer();
1045    } else {
1046  44473 switch (jj_nt.kind) {
1047  21 case ABSTRACT:
1048  222 case BOOLEAN:
1049  72 case BYTE:
1050  105 case CHAR:
1051  42 case CLASS:
1052  198 case DOUBLE:
1053  1218 case FINAL:
1054  180 case FLOAT:
1055  1896 case INT:
1056  15 case INTERFACE:
1057  135 case LONG:
1058  3 case NATIVE:
1059  10618 case PRIVATE:
1060  1254 case PROTECTED:
1061  18669 case PUBLIC:
1062  72 case SHORT:
1063  1824 case STATIC:
1064  9 case SYNCHRONIZED:
1065  0 case TRANSIENT:
1066  1701 case VOID:
1067  3 case VOLATILE:
1068  0 case STRICTFP:
1069  1569 case IDENTIFIER:
1070  4479 case AT:
1071  30 case LT:
1072  44342 modifiers = Modifiers();
1073  44343 if (jj_2_4(3)) {
1074  561 ClassOrInterfaceDeclaration(modifiers);
1075  43778 } else if (jj_2_5(3)) {
1076  18 EnumDeclaration(modifiers);
1077  43763 } else if (jj_2_6(2147483647)) {
1078  3072 ConstructorDeclaration(modifiers);
1079  40692 } else if (jj_2_7(2147483647)) {
1080  13592 FieldDeclaration(modifiers);
1081    } else {
1082  27097 switch (jj_nt.kind) {
1083  3564 case BOOLEAN:
1084  3 case BYTE:
1085  66 case CHAR:
1086  75 case DOUBLE:
1087  18 case FLOAT:
1088  1500 case INT:
1089  15 case LONG:
1090  6 case SHORT:
1091  11624 case VOID:
1092  10067 case IDENTIFIER:
1093  159 case LT:
1094  27095 MethodDeclaration(modifiers);
1095  27081 break;
1096  0 case AT:
1097  0 AnnotationTypeDeclaration(modifiers);
1098  0 break;
1099  0 default:
1100  0 jj_la1[31] = jj_gen;
1101  0 jj_consume_token(-1);
1102  0 throw new ParseException();
1103    }
1104    }
1105  44314 break;
1106  129 case SEMICOLON:
1107  129 jj_consume_token(SEMICOLON);
1108  129 break;
1109  0 default:
1110  0 jj_la1[32] = jj_gen;
1111  0 jj_consume_token(-1);
1112  0 throw new ParseException();
1113    }
1114    }
1115    } catch (Throwable jjte000) {
1116  24 if (jjtc000) {
1117  24 jjtree.clearNodeScope(jjtn000);
1118  24 jjtc000 = false;
1119    } else {
1120  0 jjtree.popNode();
1121    }
1122  24 if (jjte000 instanceof RuntimeException) {
1123  24 {if (true) throw (RuntimeException)jjte000;}
1124    }
1125  0 if (jjte000 instanceof ParseException) {
1126  0 {if (true) throw (ParseException)jjte000;}
1127    }
1128  0 {if (true) throw (Error)jjte000;}
1129    } finally {
1130  44600 if (jjtc000) {
1131  44576 jjtree.closeNodeScope(jjtn000, true);
1132    }
1133    }
1134    }
1135   
 
1136  13598 toggle final public void FieldDeclaration(int modifiers) throws ParseException {
1137    /*@bgen(jjtree) FieldDeclaration */
1138  13599 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
1139  13599 boolean jjtc000 = true;
1140  13599 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1141  13599 try {
1142  13599 Type();
1143  13599 VariableDeclarator();
1144  13590 label_14:
1145    while (true) {
1146  13647 switch (jj_nt.kind) {
1147  57 case COMMA:
1148  57 ;
1149  57 break;
1150  13589 default:
1151  13590 jj_la1[33] = jj_gen;
1152  13590 break label_14;
1153    }
1154  57 jj_consume_token(COMMA);
1155  57 VariableDeclarator();
1156    }
1157  13590 jj_consume_token(SEMICOLON);
1158    } catch (Throwable jjte000) {
1159  9 if (jjtc000) {
1160  9 jjtree.clearNodeScope(jjtn000);
1161  9 jjtc000 = false;
1162    } else {
1163  0 jjtree.popNode();
1164    }
1165  9 if (jjte000 instanceof RuntimeException) {
1166  9 {if (true) throw (RuntimeException)jjte000;}
1167    }
1168  0 if (jjte000 instanceof ParseException) {
1169  0 {if (true) throw (ParseException)jjte000;}
1170    }
1171  0 {if (true) throw (Error)jjte000;}
1172    } finally {
1173  13599 if (jjtc000) {
1174  13590 jjtree.closeNodeScope(jjtn000, true);
1175    }
1176    }
1177    }
1178   
 
1179  34015 toggle final public void VariableDeclarator() throws ParseException {
1180    /*@bgen(jjtree) VariableDeclarator */
1181  34016 ASTVariableDeclarator jjtn000 = new ASTVariableDeclarator(this, JJTVARIABLEDECLARATOR);
1182  34017 boolean jjtc000 = true;
1183  34017 jjtree.openNodeScope(jjtn000);
1184  34017 try {
1185  34017 VariableDeclaratorId();
1186  34007 switch (jj_nt.kind) {
1187  28784 case ASSIGN:
1188  28785 jj_consume_token(ASSIGN);
1189  28785 VariableInitializer();
1190  28777 break;
1191  5223 default:
1192  5223 jj_la1[34] = jj_gen;
1193  5223 ;
1194    }
1195    } catch (Throwable jjte000) {
1196  9 if (jjtc000) {
1197  9 jjtree.clearNodeScope(jjtn000);
1198  9 jjtc000 = false;
1199    } else {
1200  0 jjtree.popNode();
1201    }
1202  9 if (jjte000 instanceof RuntimeException) {
1203  9 {if (true) throw (RuntimeException)jjte000;}
1204    }
1205  0 if (jjte000 instanceof ParseException) {
1206  0 {if (true) throw (ParseException)jjte000;}
1207    }
1208  0 {if (true) throw (Error)jjte000;}
1209    } finally {
1210  34014 if (jjtc000) {
1211  34007 jjtree.closeNodeScope(jjtn000, true);
1212    }
1213    }
1214    }
1215   
 
1216  60930 toggle final public void VariableDeclaratorId() throws ParseException {
1217    /*@bgen(jjtree) VariableDeclaratorId */
1218  60937 ASTVariableDeclaratorId jjtn000 = new ASTVariableDeclaratorId(this, JJTVARIABLEDECLARATORID);
1219  60941 boolean jjtc000 = true;
1220  60941 jjtree.openNodeScope(jjtn000);Token t;
1221  60941 try {
1222  60940 t = jj_consume_token(IDENTIFIER);
1223  60942 label_15:
1224    while (true) {
1225  61090 switch (jj_nt.kind) {
1226  150 case LBRACKET:
1227  150 ;
1228  150 break;
1229  60932 default:
1230  60938 jj_la1[35] = jj_gen;
1231  60940 break label_15;
1232    }
1233  150 jj_consume_token(LBRACKET);
1234  150 jj_consume_token(RBRACKET);
1235  150 jjtn000.bumpArrayDepth();
1236    }
1237  60935 jjtree.closeNodeScope(jjtn000, true);
1238  60942 jjtc000 = false;
1239  60939 checkForBadAssertUsage(t.image, "a variable name");
1240  60935 checkForBadEnumUsage(t.image, "a variable name");
1241  60933 jjtn000.setImage( t.image );
1242    } finally {
1243  60942 if (jjtc000) {
1244  0 jjtree.closeNodeScope(jjtn000, true);
1245    }
1246    }
1247    }
1248   
 
1249  40379 toggle final public void VariableInitializer() throws ParseException {
1250    /*@bgen(jjtree) VariableInitializer */
1251  40380 ASTVariableInitializer jjtn000 = new ASTVariableInitializer(this, JJTVARIABLEINITIALIZER);
1252  40380 boolean jjtc000 = true;
1253  40380 jjtree.openNodeScope(jjtn000);
1254  40380 try {
1255  40380 switch (jj_nt.kind) {
1256  1194 case LBRACE:
1257  1194 ArrayInitializer();
1258  1194 break;
1259  3 case BOOLEAN:
1260  3 case BYTE:
1261  3 case CHAR:
1262  3 case DOUBLE:
1263  336 case FALSE:
1264  3 case FLOAT:
1265  3 case INT:
1266  3 case LONG:
1267  7104 case NEW:
1268  777 case NULL:
1269  3 case SHORT:
1270  87 case SUPER:
1271  81 case THIS:
1272  630 case TRUE:
1273  0 case VOID:
1274  10308 case INTEGER_LITERAL:
1275  354 case FLOATING_POINT_LITERAL:
1276  105 case HEX_FLOATING_POINT_LITERAL:
1277  378 case CHARACTER_LITERAL:
1278  5880 case STRING_LITERAL:
1279  9233 case IDENTIFIER:
1280  2808 case LPAREN:
1281  12 case BANG:
1282  15 case TILDE:
1283  3 case INCR:
1284  0 case DECR:
1285  15 case PLUS:
1286  1035 case MINUS:
1287  39185 Expression();
1288  39177 break;
1289  0 default:
1290  0 jj_la1[36] = jj_gen;
1291  0 jj_consume_token(-1);
1292  0 throw new ParseException();
1293    }
1294    } catch (Throwable jjte000) {
1295  0 if (jjtc000) {
1296  0 jjtree.clearNodeScope(jjtn000);
1297  0 jjtc000 = false;
1298    } else {
1299  0 jjtree.popNode();
1300    }
1301  0 if (jjte000 instanceof RuntimeException) {
1302  0 {if (true) throw (RuntimeException)jjte000;}
1303    }
1304  0 if (jjte000 instanceof ParseException) {
1305  0 {if (true) throw (ParseException)jjte000;}
1306    }
1307  0 {if (true) throw (Error)jjte000;}
1308    } finally {
1309  40373 if (jjtc000) {
1310  40376 jjtree.closeNodeScope(jjtn000, true);
1311    }
1312    }
1313    }
1314   
 
1315  1878 toggle final public void ArrayInitializer() throws ParseException {
1316    /*@bgen(jjtree) ArrayInitializer */
1317  1878 ASTArrayInitializer jjtn000 = new ASTArrayInitializer(this, JJTARRAYINITIALIZER);
1318  1878 boolean jjtc000 = true;
1319  1878 jjtree.openNodeScope(jjtn000);
1320  1878 try {
1321  1878 jj_consume_token(LBRACE);
1322  1878 switch (jj_nt.kind) {
1323  0 case BOOLEAN:
1324  0 case BYTE:
1325  0 case CHAR:
1326  0 case DOUBLE:
1327  9 case FALSE:
1328  0 case FLOAT:
1329  3 case INT:
1330  0 case LONG:
1331  15 case NEW:
1332  6 case NULL:
1333  0 case SHORT:
1334  0 case SUPER:
1335  0 case THIS:
1336  6 case TRUE:
1337  0 case VOID:
1338  894 case INTEGER_LITERAL:
1339  9 case FLOATING_POINT_LITERAL:
1340  0 case HEX_FLOATING_POINT_LITERAL:
1341  12 case CHARACTER_LITERAL:
1342  525 case STRING_LITERAL:
1343  192 case IDENTIFIER:
1344  6 case LPAREN:
1345  93 case LBRACE:
1346  0 case BANG:
1347  0 case TILDE:
1348  0 case INCR:
1349  0 case DECR:
1350  0 case PLUS:
1351  18 case MINUS:
1352  1788 VariableInitializer();
1353  1788 label_16:
1354    while (true) {
1355  11595 if (jj_2_9(2)) {
1356  9807 ;
1357    } else {
1358  1788 break label_16;
1359    }
1360  9807 jj_consume_token(COMMA);
1361  9807 VariableInitializer();
1362    }
1363  1788 break;
1364  90 default:
1365  90 jj_la1[37] = jj_gen;
1366  90 ;
1367    }
1368  1878 switch (jj_nt.kind) {
1369  153 case COMMA:
1370  153 jj_consume_token(COMMA);
1371  153 break;
1372  1725 default:
1373  1725 jj_la1[38] = jj_gen;
1374  1725 ;
1375    }
1376  1878 jj_consume_token(RBRACE);
1377    } catch (Throwable jjte000) {
1378  0 if (jjtc000) {
1379  0 jjtree.clearNodeScope(jjtn000);
1380  0 jjtc000 = false;
1381    } else {
1382  0 jjtree.popNode();
1383    }
1384  0 if (jjte000 instanceof RuntimeException) {
1385  0 {if (true) throw (RuntimeException)jjte000;}
1386    }
1387  0 if (jjte000 instanceof ParseException) {
1388  0 {if (true) throw (ParseException)jjte000;}
1389    }
1390  0 {if (true) throw (Error)jjte000;}
1391    } finally {
1392  1878 if (jjtc000) {
1393  1878 jjtree.closeNodeScope(jjtn000, true);
1394    }
1395    }
1396    }
1397   
 
1398  27092 toggle final public void MethodDeclaration(int modifiers) throws ParseException {
1399    /*@bgen(jjtree) MethodDeclaration */
1400  27098 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
1401  27099 boolean jjtc000 = true;
1402  27096 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1403  27094 try {
1404  27096 switch (jj_nt.kind) {
1405  159 case LT:
1406  159 TypeParameters();
1407  159 break;
1408  26936 default:
1409  26937 jj_la1[39] = jj_gen;
1410  26935 ;
1411    }
1412  27099 ResultType();
1413  27096 MethodDeclarator();
1414  27091 switch (jj_nt.kind) {
1415  2370 case THROWS:
1416  2370 jj_consume_token(THROWS);
1417  2370 NameList();
1418  2370 break;
1419  24723 default:
1420  24722 jj_la1[40] = jj_gen;
1421  24722 ;
1422    }
1423  27093 switch (jj_nt.kind) {
1424  25415 case LBRACE:
1425  25416 Block();
1426  25406 break;
1427  1677 case SEMICOLON:
1428  1677 jj_consume_token(SEMICOLON);
1429  1677 break;
1430  0 default:
1431  0 jj_la1[41] = jj_gen;
1432  0 jj_consume_token(-1);
1433  0 throw new ParseException();
1434    }
1435    } catch (Throwable jjte000) {
1436  12 if (jjtc000) {
1437  12 jjtree.clearNodeScope(jjtn000);
1438  12 jjtc000 = false;
1439    } else {
1440  0 jjtree.popNode();
1441    }
1442  12 if (jjte000 instanceof RuntimeException) {
1443  12 {if (true) throw (RuntimeException)jjte000;}
1444    }
1445  0 if (jjte000 instanceof ParseException) {
1446  0 {if (true) throw (ParseException)jjte000;}
1447    }
1448  0 {if (true) throw (Error)jjte000;}
1449    } finally {
1450  27097 if (jjtc000) {
1451  27086 jjtree.closeNodeScope(jjtn000, true);
1452    }
1453    }
1454    }
1455   
 
1456  27096 toggle final public void MethodDeclarator() throws ParseException {
1457    /*@bgen(jjtree) MethodDeclarator */
1458  27098 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
1459  27099 boolean jjtc000 = true;
1460  27099 jjtree.openNodeScope(jjtn000);Token t;
1461  27099 try {
1462  27098 t = jj_consume_token(IDENTIFIER);
1463  27098 checkForBadAssertUsage(t.image, "a method name");
1464  27096 checkForBadEnumUsage(t.image, "a method name");
1465  27096 jjtn000.setImage( t.image );
1466  27095 FormalParameters();
1467  27089 label_17:
1468    while (true) {
1469  27091 switch (jj_nt.kind) {
1470  0 case LBRACKET:
1471  0 ;
1472  0 break;
1473  27090 default:
1474  27092 jj_la1[42] = jj_gen;
1475  27092 break label_17;
1476    }
1477  0 jj_consume_token(LBRACKET);
1478  0 jj_consume_token(RBRACKET);
1479    }
1480    } catch (Throwable jjte000) {
1481  6 if (jjtc000) {
1482  6 jjtree.clearNodeScope(jjtn000);
1483  6 jjtc000 = false;
1484    } else {
1485  0 jjtree.popNode();
1486    }
1487  6 if (jjte000 instanceof RuntimeException) {
1488  6 {if (true) throw (RuntimeException)jjte000;}
1489    }
1490  0 if (jjte000 instanceof ParseException) {
1491  0 {if (true) throw (ParseException)jjte000;}
1492    }
1493  0 {if (true) throw (Error)jjte000;}
1494    } finally {
1495  27099 if (jjtc000) {
1496  27093 jjtree.closeNodeScope(jjtn000, true);
1497    }
1498    }
1499    }
1500   
 
1501  30162 toggle final public void FormalParameters() throws ParseException {
1502    /*@bgen(jjtree) FormalParameters */
1503  30167 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
1504  30167 boolean jjtc000 = true;
1505  30168 jjtree.openNodeScope(jjtn000);
1506  30168 try {
1507  30168 jj_consume_token(LPAREN);
1508  30168 switch (jj_nt.kind) {
1509  474 case BOOLEAN:
1510  18 case BYTE:
1511  72 case CHAR:
1512  30 case DOUBLE:
1513  162 case FINAL:
1514  18 case FLOAT:
1515  2067 case INT:
1516  195 case LONG:
1517  6 case SHORT:
1518  12332 case IDENTIFIER:
1519  9 case AT:
1520  15384 FormalParameter();
1521  15377 label_18:
1522    while (true) {
1523  25028 switch (jj_nt.kind) {
1524  9649 case COMMA:
1525  9651 ;
1526  9651 break;
1527  15380 default:
1528  15381 jj_la1[43] = jj_gen;
1529  15381 break label_18;
1530    }
1531  9651 jj_consume_token(COMMA);
1532  9651 FormalParameter();
1533    }
1534  15381 break;
1535  14782 default:
1536  14783 jj_la1[44] = jj_gen;
1537  14781 ;
1538    }
1539  30165 jj_consume_token(RPAREN);
1540    } catch (Throwable jjte000) {
1541  3 if (jjtc000) {
1542  3 jjtree.clearNodeScope(jjtn000);
1543  3 jjtc000 = false;
1544    } else {
1545  0 jjtree.popNode();
1546    }
1547  3 if (jjte000 instanceof RuntimeException) {
1548  3 {if (true) throw (RuntimeException)jjte000;}
1549    }
1550  0 if (jjte000 instanceof ParseException) {
1551  0 {if (true) throw (ParseException)jjte000;}
1552    }
1553  0 {if (true) throw (Error)jjte000;}
1554    } finally {
1555  30168 if (jjtc000) {
1556  30165 jjtree.closeNodeScope(jjtn000, true);
1557    }
1558    }
1559    }
1560   
 
1561  26909 toggle final public void FormalParameter() throws ParseException {
1562    /*@bgen(jjtree) FormalParameter */
1563  26912 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
1564  26911 boolean jjtc000 = true;
1565  26912 jjtree.openNodeScope(jjtn000);
1566  26910 try {
1567  26911 label_19:
1568    while (true) {
1569  27234 switch (jj_nt.kind) {
1570  309 case FINAL:
1571  15 case AT:
1572  324 ;
1573  324 break;
1574  26913 default:
1575  26913 jj_la1[45] = jj_gen;
1576  26910 break label_19;
1577    }
1578  324 switch (jj_nt.kind) {
1579  309 case FINAL:
1580  309 jj_consume_token(FINAL);
1581  309 jjtn000.setFinal(true);
1582  309 break;
1583  15 case AT:
1584  15 Annotation();
1585  15 break;
1586  0 default:
1587  0 jj_la1[46] = jj_gen;
1588  0 jj_consume_token(-1);
1589  0 throw new ParseException();
1590    }
1591    }
1592  26909 Type();
1593  26909 label_20:
1594    while (true) {
1595  26929 switch (jj_nt.kind) {
1596  18 case BIT_OR:
1597  18 ;
1598  18 break;
1599  26912 default:
1600  26913 jj_la1[47] = jj_gen;
1601  26906 break label_20;
1602    }
1603  18 jj_consume_token(BIT_OR);
1604  18 Type();
1605    }
1606  26910 switch (jj_nt.kind) {
1607  102 case ELLIPSIS:
1608  102 jj_consume_token(ELLIPSIS);
1609  102 checkForBadVariableArgumentsUsage();
1610  99 jjtn000.setVarargs();
1611  99 break;
1612  26808 default:
1613  26809 jj_la1[48] = jj_gen;
1614  26811 ;
1615    }
1616  26910 VariableDeclaratorId();
1617    } catch (Throwable jjte000) {
1618  3 if (jjtc000) {
1619  3 jjtree.clearNodeScope(jjtn000);
1620  3 jjtc000 = false;
1621    } else {
1622  0 jjtree.popNode();
1623    }
1624  3 if (jjte000 instanceof RuntimeException) {
1625  3 {if (true) throw (RuntimeException)jjte000;}
1626    }
1627  0 if (jjte000 instanceof ParseException) {
1628  0 {if (true) throw (ParseException)jjte000;}
1629    }
1630  0 {if (true) throw (Error)jjte000;}
1631    } finally {
1632  26912 if (jjtc000) {
1633  26901 jjtree.closeNodeScope(jjtn000, true);
1634    }
1635    }
1636    }
1637   
 
1638  3072 toggle final public void ConstructorDeclaration(int modifiers) throws ParseException {
1639    /*@bgen(jjtree) ConstructorDeclaration */
1640  3072 ASTConstructorDeclaration jjtn000 = new ASTConstructorDeclaration(this, JJTCONSTRUCTORDECLARATION);
1641  3072 boolean jjtc000 = true;
1642  3072 jjtree.openNodeScope(jjtn000);jjtn000.setModifiers(modifiers);
1643  3071 Token t;
1644  3072 try {
1645  3072 switch (jj_nt.kind) {
1646  6 case LT:
1647  6 TypeParameters();
1648  6 break;
1649  3066 default:
1650  3066 jj_la1[49] = jj_gen;
1651  3065 ;
1652    }
1653  3072 jj_consume_token(IDENTIFIER);
1654  3072 FormalParameters();
1655  3069 switch (jj_nt.kind) {
1656  33 case THROWS:
1657  33 jj_consume_token(THROWS);
1658  33 NameList();
1659  33 break;
1660  3038 default:
1661  3039 jj_la1[50] = jj_gen;
1662  3038 ;
1663    }
1664  3071 jj_consume_token(LBRACE);
1665  3069 if (jj_2_10(2147483647)) {
1666  1751 ExplicitConstructorInvocation();
1667    } else {
1668  1320 ;
1669    }
1670  3070 label_21:
1671    while (true) {
1672  6395 if (jj_2_11(1)) {
1673  3327 ;
1674    } else {
1675  3071 break label_21;
1676    }
1677  3327 BlockStatement();
1678    }
1679  3069 t = jj_consume_token(RBRACE);
1680  3071 jjtree.closeNodeScope(jjtn000, true);
1681  3072 jjtc000 = false;
1682  3071 if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
1683    } catch (Throwable jjte000) {
1684  0 if (jjtc000) {
1685  0 jjtree.clearNodeScope(jjtn000);
1686  0 jjtc000 = false;
1687    } else {
1688  0 jjtree.popNode();
1689    }
1690  0 if (jjte000 instanceof RuntimeException) {
1691  0 {if (true) throw (RuntimeException)jjte000;}
1692    }
1693  0 if (jjte000 instanceof ParseException) {
1694  0 {if (true) throw (ParseException)jjte000;}
1695    }
1696  0 {if (true) throw (Error)jjte000;}
1697    } finally {
1698  3068 if (jjtc000) {
1699  0 jjtree.closeNodeScope(jjtn000, true);
1700    }
1701    }
1702    }
1703   
 
1704  1748 toggle final public void ExplicitConstructorInvocation() throws ParseException {
1705    /*@bgen(jjtree) ExplicitConstructorInvocation */
1706  1750 ASTExplicitConstructorInvocation jjtn000 = new ASTExplicitConstructorInvocation(this, JJTEXPLICITCONSTRUCTORINVOCATION);
1707  1749 boolean jjtc000 = true;
1708  1748 jjtree.openNodeScope(jjtn000);
1709  1752 try {
1710  1751 if (jj_2_13(2147483647)) {
1711  237 jj_consume_token(THIS);
1712  237 jjtn000.setIsThis();
1713  237 Arguments();
1714  237 jj_consume_token(SEMICOLON);
1715    } else {
1716  1514 switch (jj_nt.kind) {
1717  0 case BOOLEAN:
1718  0 case BYTE:
1719  0 case CHAR:
1720  0 case DOUBLE:
1721  0 case FALSE:
1722  0 case FLOAT:
1723  0 case INT:
1724  0 case LONG:
1725  0 case NEW:
1726  0 case NULL:
1727  0 case SHORT:
1728  1510 case SUPER:
1729  0 case THIS:
1730  0 case TRUE:
1731  0 case VOID:
1732  0 case INTEGER_LITERAL:
1733  0 case FLOATING_POINT_LITERAL:
1734  0 case HEX_FLOATING_POINT_LITERAL:
1735  0 case CHARACTER_LITERAL:
1736  0 case STRING_LITERAL:
1737  0 case IDENTIFIER:
1738  0 case LPAREN:
1739  1515 if (jj_2_12(2)) {
1740  0 PrimaryExpression();
1741  0 jj_consume_token(DOT);
1742  0 jj_consume_token(SUPER);
1743  0 jj_consume_token(LPAREN);
1744    } else {
1745  1514 ;
1746    }
1747  1513 switch (jj_nt.kind) {
1748  1514 case SUPER:
1749  1512 jj_consume_token(SUPER);
1750  1513 break;
1751  0 case THIS:
1752  0 jj_consume_token(THIS);
1753  0 break;
1754  0 default:
1755  0 jj_la1[51] = jj_gen;
1756  0 jj_consume_token(-1);
1757  0 throw new ParseException();
1758    }
1759  1513 Arguments();
1760  1511 jj_consume_token(SEMICOLON);
1761  1515 break;
1762  0 default:
1763  0 jj_la1[52] = jj_gen;
1764  0 jj_consume_token(-1);
1765  0 throw new ParseException();
1766    }
1767    }
1768    } catch (Throwable jjte000) {
1769  0 if (jjtc000) {
1770  0 jjtree.clearNodeScope(jjtn000);
1771  0 jjtc000 = false;
1772    } else {
1773  0 jjtree.popNode();
1774    }
1775  0 if (jjte000 instanceof RuntimeException) {
1776  0 {if (true) throw (RuntimeException)jjte000;}
1777    }
1778  0 if (jjte000 instanceof ParseException) {
1779  0 {if (true) throw (ParseException)jjte000;}
1780    }
1781  0 {if (true) throw (Error)jjte000;}
1782    } finally {
1783  1751 if (jjtc000) {
1784  1752 jjtree.closeNodeScope(jjtn000, true);
1785    }
1786    }
1787    }
1788   
 
1789  126 toggle final public void Initializer() throws ParseException {
1790    /*@bgen(jjtree) Initializer */
1791  126 ASTInitializer jjtn000 = new ASTInitializer(this, JJTINITIALIZER);
1792  126 boolean jjtc000 = true;
1793  126 jjtree.openNodeScope(jjtn000);
1794  126 try {
1795  126 switch (jj_nt.kind) {
1796  99 case STATIC:
1797  99 jj_consume_token(STATIC);
1798  99 jjtn000.setStatic();
1799  99 break;
1800  27 default:
1801  27 jj_la1[53] = jj_gen;
1802  27 ;
1803    }
1804  126 Block();
1805    } catch (Throwable jjte000) {
1806  0 if (jjtc000) {
1807  0 jjtree.clearNodeScope(jjtn000);
1808  0 jjtc000 = false;
1809    } else {
1810  0 jjtree.popNode();
1811    }
1812  0 if (jjte000 instanceof RuntimeException) {
1813  0 {if (true) throw (RuntimeException)jjte000;}
1814    }
1815  0 if (jjte000 instanceof ParseException) {
1816  0 {if (true) throw (ParseException)jjte000;}
1817    }
1818  0 {if (true) throw (Error)jjte000;}
1819    } finally {
1820  126 if (jjtc000) {
1821  126 jjtree.closeNodeScope(jjtn000, true);
1822    }
1823    }
1824    }
1825   
1826    /*
1827    * Type, name and expression syntax follows.
1828    */
 
1829  92364 toggle final public void Type() throws ParseException {
1830    /*@bgen(jjtree) Type */
1831  92373 ASTType jjtn000 = new ASTType(this, JJTTYPE);
1832  92372 boolean jjtc000 = true;
1833  92374 jjtree.openNodeScope(jjtn000);
1834  92374 try {
1835  92369 if (jj_2_14(2)) {
1836  68056 ReferenceType();
1837    } else {
1838  24318 switch (jj_nt.kind) {
1839  5826 case BOOLEAN:
1840  555 case BYTE:
1841  867 case CHAR:
1842  1338 case DOUBLE:
1843  1065 case FLOAT:
1844  12519 case INT:
1845  1593 case LONG:
1846  552 case SHORT:
1847  24315 PrimitiveType();
1848  24316 break;
1849  0 default:
1850  0 jj_la1[54] = jj_gen;
1851  0 jj_consume_token(-1);
1852  0 throw new ParseException();
1853    }
1854    }
1855    } catch (Throwable jjte000) {
1856  0 if (jjtc000) {
1857  0 jjtree.clearNodeScope(jjtn000);
1858  0 jjtc000 = false;
1859    } else {
1860  0 jjtree.popNode();
1861    }
1862  0 if (jjte000 instanceof RuntimeException) {
1863  0 {if (true) throw (RuntimeException)jjte000;}
1864    }
1865  0 if (jjte000 instanceof ParseException) {
1866  0 {if (true) throw (ParseException)jjte000;}
1867    }
1868  0 {if (true) throw (Error)jjte000;}
1869    } finally {
1870  92373 if (jjtc000) {
1871  92367 jjtree.closeNodeScope(jjtn000, true);
1872    }
1873    }
1874    }
1875   
 
1876  76409 toggle final public void ReferenceType() throws ParseException {
1877    /*@bgen(jjtree) ReferenceType */
1878  76416 ASTReferenceType jjtn000 = new ASTReferenceType(this, JJTREFERENCETYPE);
1879  76413 boolean jjtc000 = true;
1880  76414 jjtree.openNodeScope(jjtn000);
1881  76414 try {
1882  76414 switch (jj_nt.kind) {
1883  21 case BOOLEAN:
1884  18 case BYTE:
1885  81 case CHAR:
1886  36 case DOUBLE:
1887  9 case FLOAT:
1888  288 case INT:
1889  234 case LONG:
1890  9 case SHORT:
1891  696 PrimitiveType();
1892  696 label_22:
1893    while (true) {
1894  792 jj_consume_token(LBRACKET);
1895  792 jj_consume_token(RBRACKET);
1896  792 jjtn000.bumpArrayDepth();
1897  792 if (jj_2_15(2)) {
1898  96 ;
1899    } else {
1900  696 break label_22;
1901    }
1902    }
1903  696 break;
1904  75712 case IDENTIFIER:
1905  75714 ClassOrInterfaceType();
1906  75713 label_23:
1907    while (true) {
1908  77630 if (jj_2_16(2)) {
1909  1911 ;
1910    } else {
1911  75718 break label_23;
1912    }
1913  1911 jj_consume_token(LBRACKET);
1914  1911 jj_consume_token(RBRACKET);
1915  1911 jjtn000.bumpArrayDepth();
1916    }
1917  75713 break;
1918  0 default:
1919  0 jj_la1[55] = jj_gen;
1920  0 jj_consume_token(-1);
1921  0 throw new ParseException();
1922    }
1923    } catch (Throwable jjte000) {
1924  0 if (jjtc000) {
1925  0 jjtree.clearNodeScope(jjtn000);
1926  0 jjtc000 = false;
1927    } else {
1928  0 jjtree.popNode();
1929    }
1930  0 if (jjte000 instanceof RuntimeException) {
1931  0 {if (true) throw (RuntimeException)jjte000;}
1932    }
1933  0 if (jjte000 instanceof ParseException) {
1934  0 {if (true) throw (ParseException)jjte000;}
1935    }
1936  0 {if (true) throw (Error)jjte000;}
1937    } finally {
1938  76411 if (jjtc000) {
1939  76410 jjtree.closeNodeScope(jjtn000, true);
1940    }
1941    }
1942    }
1943   
 
1944  92252 toggle final public void ClassOrInterfaceType() throws ParseException {
1945    /*@bgen(jjtree) ClassOrInterfaceType */
1946  92258 ASTClassOrInterfaceType jjtn000 = new ASTClassOrInterfaceType(this, JJTCLASSORINTERFACETYPE);
1947  92256 boolean jjtc000 = true;
1948  92256 jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
1949  92257 Token t;
1950  92258 try {
1951  92256 t = jj_consume_token(IDENTIFIER);
1952  92255 s.append(t.image);
1953  92250 if (jj_2_17(2)) {
1954  7944 TypeArguments();
1955    } else {
1956  84311 ;
1957    }
1958  92255 label_24:
1959    while (true) {
1960  96399 if (jj_2_18(2)) {
1961  4143 ;
1962    } else {
1963  92257 break label_24;
1964    }
1965  4143 jj_consume_token(DOT);
1966  4141 t = jj_consume_token(IDENTIFIER);
1967  4143 s.append('.').append(t.image);
1968  4143 if (jj_2_19(2)) {
1969  135 TypeArguments();
1970    } else {
1971  4008 ;
1972    }
1973    }
1974  92250 jjtree.closeNodeScope(jjtn000, true);
1975  92255 jjtc000 = false;
1976  92256 jjtn000.setImage(s.toString());
1977    } catch (Throwable jjte000) {
1978  0 if (jjtc000) {
1979  0 jjtree.clearNodeScope(jjtn000);
1980  0 jjtc000 = false;
1981    } else {
1982  0 jjtree.popNode();
1983    }
1984  0 if (jjte000 instanceof RuntimeException) {
1985  0 {if (true) throw (RuntimeException)jjte000;}
1986    }
1987  0 if (jjte000 instanceof ParseException) {
1988  0 {if (true) throw (ParseException)jjte000;}
1989    }
1990  0 {if (true) throw (Error)jjte000;}
1991    } finally {
1992  92254 if (jjtc000) {
1993  0 jjtree.closeNodeScope(jjtn000, true);
1994    }
1995    }
1996    }
1997   
 
1998  8106 toggle final public void TypeArguments() throws ParseException {
1999    /*@bgen(jjtree) TypeArguments */
2000  8106 ASTTypeArguments jjtn000 = new ASTTypeArguments(this, JJTTYPEARGUMENTS);
2001  8106 boolean jjtc000 = true;
2002  8106 jjtree.openNodeScope(jjtn000);
2003  8106 try {
2004  8106 if (jj_2_20(2)) {
2005  8103 jj_consume_token(LT);
2006  8103 checkForBadGenericsUsage();
2007  8103 TypeArgument();
2008  8103 label_25:
2009    while (true) {
2010  9282 switch (jj_nt.kind) {
2011  1179 case COMMA:
2012  1179 ;
2013  1179 break;
2014  8103 default:
2015  8103 jj_la1[56] = jj_gen;
2016  8103 break label_25;
2017    }
2018  1179 jj_consume_token(COMMA);
2019  1179 TypeArgument();
2020    }
2021  8103 jj_consume_token(GT);
2022    } else {
2023  3 switch (jj_nt.kind) {
2024  3 case LT:
2025  3 jj_consume_token(LT);
2026  3 checkForBadDiamondUsage();
2027  3 jj_consume_token(GT);
2028  3 break;
2029  0 default:
2030  0 jj_la1[57] = jj_gen;
2031  0 jj_consume_token(-1);
2032  0 throw new ParseException();
2033    }
2034    }
2035    } catch (Throwable jjte000) {
2036  0 if (jjtc000) {
2037  0 jjtree.clearNodeScope(jjtn000);
2038  0 jjtc000 = false;
2039    } else {
2040  0 jjtree.popNode();
2041    }
2042  0 if (jjte000 instanceof RuntimeException) {
2043  0 {if (true) throw (RuntimeException)jjte000;}
2044    }
2045  0 if (jjte000 instanceof ParseException) {
2046  0 {if (true) throw (ParseException)jjte000;}
2047    }
2048  0 {if (true) throw (Error)jjte000;}
2049    } finally {
2050  8106 if (jjtc000) {
2051  8106 jjtree.closeNodeScope(jjtn000, true);
2052    }
2053    }
2054    }
2055   
 
2056  9282 toggle final public void TypeArgument() throws ParseException {
2057    /*@bgen(jjtree) TypeArgument */
2058  9282 ASTTypeArgument jjtn000 = new ASTTypeArgument(this, JJTTYPEARGUMENT);
2059  9282 boolean jjtc000 = true;
2060  9282 jjtree.openNodeScope(jjtn000);
2061  9282 try {
2062  9282 switch (jj_nt.kind) {
2063  0 case BOOLEAN:
2064  0 case BYTE:
2065  0 case CHAR:
2066  0 case DOUBLE:
2067  0 case FLOAT:
2068  6 case INT:
2069  0 case LONG:
2070  0 case SHORT:
2071  8208 case IDENTIFIER:
2072  8214 ReferenceType();
2073  8214 break;
2074  1068 case HOOK:
2075  1068 jj_consume_token(HOOK);
2076  1068 switch (jj_nt.kind) {
2077  144 case EXTENDS:
2078  0 case SUPER:
2079  144 WildcardBounds();
2080  144 break;
2081  924 default:
2082  924 jj_la1[58] = jj_gen;
2083  924 ;
2084    }
2085  1068 break;
2086  0 default:
2087  0 jj_la1[59] = jj_gen;
2088  0 jj_consume_token(-1);
2089  0 throw new ParseException();
2090    }
2091    } catch (Throwable jjte000) {
2092  0 if (jjtc000) {
2093  0 jjtree.clearNodeScope(jjtn000);
2094  0 jjtc000 = false;
2095    } else {
2096  0 jjtree.popNode();
2097    }
2098  0 if (jjte000 instanceof RuntimeException) {
2099  0 {if (true) throw (RuntimeException)jjte000;}
2100    }
2101  0 if (jjte000 instanceof ParseException) {
2102  0 {if (true) throw (ParseException)jjte000;}
2103    }
2104  0 {if (true) throw (Error)jjte000;}
2105    } finally {
2106  9282 if (jjtc000) {
2107  9282 jjtree.closeNodeScope(jjtn000, true);
2108    }
2109    }
2110    }
2111   
 
2112  144 toggle final public void WildcardBounds() throws ParseException {
2113    /*@bgen(jjtree) WildcardBounds */
2114  144 ASTWildcardBounds jjtn000 = new ASTWildcardBounds(this, JJTWILDCARDBOUNDS);
2115  144 boolean jjtc000 = true;
2116  144 jjtree.openNodeScope(jjtn000);
2117  144 try {
2118  144 switch (jj_nt.kind) {
2119  144 case EXTENDS:
2120  144 jj_consume_token(EXTENDS);
2121  144 ReferenceType();
2122  144 break;
2123  0 case SUPER:
2124  0 jj_consume_token(SUPER);
2125  0 ReferenceType();
2126  0 break;
2127  0 default:
2128  0 jj_la1[60] = jj_gen;
2129  0 jj_consume_token(-1);
2130  0 throw new ParseException();
2131    }
2132    } catch (Throwable jjte000) {
2133  0 if (jjtc000) {
2134  0 jjtree.clearNodeScope(jjtn000);
2135  0 jjtc000 = false;
2136    } else {
2137  0 jjtree.popNode();
2138    }
2139  0 if (jjte000 instanceof RuntimeException) {
2140  0 {if (true) throw (RuntimeException)jjte000;}
2141    }
2142  0 if (jjte000 instanceof ParseException) {
2143  0 {if (true) throw (ParseException)jjte000;}
2144    }
2145  0 {if (true) throw (Error)jjte000;}
2146    } finally {
2147  144 if (jjtc000) {
2148  144 jjtree.closeNodeScope(jjtn000, true);
2149    }
2150    }
2151    }
2152   
 
2153  25238 toggle final public void PrimitiveType() throws ParseException {
2154    /*@bgen(jjtree) PrimitiveType */
2155  25241 ASTPrimitiveType jjtn000 = new ASTPrimitiveType(this, JJTPRIMITIVETYPE);
2156  25242 boolean jjtc000 = true;
2157  25242 jjtree.openNodeScope(jjtn000);
2158  25241 try {
2159  25242 switch (jj_nt.kind) {
2160  5856 case BOOLEAN:
2161  5856 jj_consume_token(BOOLEAN);
2162  5856 jjtree.closeNodeScope(jjtn000, true);
2163  5856 jjtc000 = false;
2164  5856 jjtn000.setImage("boolean");
2165  5856 break;
2166  996 case CHAR:
2167  996 jj_consume_token(CHAR);
2168  996 jjtree.closeNodeScope(jjtn000, true);
2169  996 jjtc000 = false;
2170  996 jjtn000.setImage("char");
2171  996 break;
2172  585 case BYTE:
2173  585 jj_consume_token(BYTE);
2174  585 jjtree.closeNodeScope(jjtn000, true);
2175  585 jjtc000 = false;
2176  585 jjtn000.setImage("byte");
2177  585 break;
2178  564 case SHORT:
2179  564 jj_consume_token(SHORT);
2180  564 jjtree.closeNodeScope(jjtn000, true);
2181  564 jjtc000 = false;
2182  564 jjtn000.setImage("short");
2183  564 break;
2184  12945 case INT:
2185  12948 jj_consume_token(INT);
2186  12945 jjtree.closeNodeScope(jjtn000, true);
2187  12948 jjtc000 = false;
2188  12948 jjtn000.setImage("int");
2189  12948 break;
2190  1833 case LONG:
2191  1833 jj_consume_token(LONG);
2192  1833 jjtree.closeNodeScope(jjtn000, true);
2193  1833 jjtc000 = false;
2194  1833 jjtn000.setImage("long");
2195  1833 break;
2196  1077 case FLOAT:
2197  1077 jj_consume_token(FLOAT);
2198  1077 jjtree.closeNodeScope(jjtn000, true);
2199  1077 jjtc000 = false;
2200  1077 jjtn000.setImage("float");
2201  1077 break;
2202  1383 case DOUBLE:
2203  1383 jj_consume_token(DOUBLE);
2204  1383 jjtree.closeNodeScope(jjtn000, true);
2205  1383 jjtc000 = false;
2206  1383 jjtn000.setImage("double");
2207  1383 break;
2208  0 default:
2209  0 jj_la1[61] = jj_gen;
2210  0 jj_consume_token(-1);
2211  0 throw new ParseException();
2212    }
2213    } finally {
2214  25241 if (jjtc000) {
2215  0 jjtree.closeNodeScope(jjtn000, true);
2216    }
2217    }
2218    }
2219   
 
2220  30869 toggle final public void ResultType() throws ParseException {
2221    /*@bgen(jjtree) ResultType */
2222  30876 ASTResultType jjtn000 = new ASTResultType(this, JJTRESULTTYPE);
2223  30874 boolean jjtc000 = true;
2224  30877 jjtree.openNodeScope(jjtn000);
2225  30879 try {
2226  30878 switch (jj_nt.kind) {
2227  11667 case VOID:
2228  11667 jj_consume_token(VOID);
2229  11665 break;
2230  3579 case BOOLEAN:
2231  12 case BYTE:
2232  72 case CHAR:
2233  81 case DOUBLE:
2234  27 case FLOAT:
2235  1512 case INT:
2236  24 case LONG:
2237  12 case SHORT:
2238  13890 case IDENTIFIER:
2239  19209 Type();
2240  19212 break;
2241  0 default:
2242  0 jj_la1[62] = jj_gen;
2243  0 jj_consume_token(-1);
2244  0 throw new ParseException();
2245    }
2246    } catch (Throwable jjte000) {
2247  0 if (jjtc000) {
2248  0 jjtree.clearNodeScope(jjtn000);
2249  0 jjtc000 = false;
2250    } else {
2251  0 jjtree.popNode();
2252    }
2253  0 if (jjte000 instanceof RuntimeException) {
2254  0 {if (true) throw (RuntimeException)jjte000;}
2255    }
2256  0 if (jjte000 instanceof ParseException) {
2257  0 {if (true) throw (ParseException)jjte000;}
2258    }
2259  0 {if (true) throw (Error)jjte000;}
2260    } finally {
2261  30879 if (jjtc000) {
2262  30878 jjtree.closeNodeScope(jjtn000, true);
2263    }
2264    }
2265    }
2266   
 
2267  209673 toggle final public void Name() throws ParseException {
2268    /*@bgen(jjtree) Name */
2269  209746 ASTName jjtn000 = new ASTName(this, JJTNAME);
2270  209745 boolean jjtc000 = true;
2271  209731 jjtree.openNodeScope(jjtn000);StringBuffer s = new StringBuffer();
2272  209712 Token t;
2273  209745 try {
2274  209710 t = jj_consume_token(IDENTIFIER);
2275  209738 jjtn000.testingOnly__setBeginLine( t.beginLine);
2276  209744 jjtn000.testingOnly__setBeginColumn( t.beginColumn);
2277  209734 s.append(t.image);
2278  209738 label_26:
2279    while (true) {
2280  355713 if (jj_2_21(2)) {
2281  145961 ;
2282    } else {
2283  209733 break label_26;
2284    }
2285  145957 jj_consume_token(DOT);
2286  145957 t = jj_consume_token(IDENTIFIER);
2287  145970 s.append('.').append(t.image);
2288    }
2289  209723 jjtree.closeNodeScope(jjtn000, true);
2290  209759 jjtc000 = false;
2291  209730 jjtn000.setImage(s.toString());
2292    } finally {
2293  209719 if (jjtc000) {
2294  0 jjtree.closeNodeScope(jjtn000, true);
2295    }
2296    }
2297    }
2298   
 
2299  2403 toggle final public void NameList() throws ParseException {
2300    /*@bgen(jjtree) NameList */
2301  2403 ASTNameList jjtn000 = new ASTNameList(this, JJTNAMELIST);
2302  2403 boolean jjtc000 = true;
2303  2403 jjtree.openNodeScope(jjtn000);
2304  2403 try {
2305  2403 Name();
2306  2403 label_27:
2307    while (true) {
2308  2550 switch (jj_nt.kind) {
2309  147 case COMMA:
2310  147 ;
2311  147 break;
2312  2403 default:
2313  2403 jj_la1[63] = jj_gen;
2314  2403 break label_27;
2315    }
2316  147 jj_consume_token(COMMA);
2317  147 Name();
2318    }
2319    } catch (Throwable jjte000) {
2320  0 if (jjtc000) {
2321  0 jjtree.clearNodeScope(jjtn000);
2322  0 jjtc000 = false;
2323    } else {
2324  0 jjtree.popNode();
2325    }
2326  0 if (jjte000 instanceof RuntimeException) {
2327  0 {if (true) throw (RuntimeException)jjte000;}
2328    }
2329  0 if (jjte000 instanceof ParseException) {
2330  0 {if (true) throw (ParseException)jjte000;}
2331    }
2332  0 {if (true) throw (Error)jjte000;}
2333    } finally {
2334  2403 if (jjtc000) {
2335  2403 jjtree.closeNodeScope(jjtn000, true);
2336    }
2337    }
2338    }
2339   
2340    /*
2341    * Expression syntax follows.
2342    */
 
2343  217976 toggle final public void Expression() throws ParseException {
2344    /*@bgen(jjtree) Expression */
2345  218009 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
2346  218020 boolean jjtc000 = true;
2347  217999 jjtree.openNodeScope(jjtn000);
2348  218020 try {
2349  218023 ConditionalExpression();
2350  217848 switch (jj_nt.kind) {
2351  618 case ASSIGN:
2352  9 case PLUSASSIGN:
2353  9 case MINUSASSIGN:
2354  0 case STARASSIGN:
2355  0 case SLASHASSIGN:
2356  153 case ANDASSIGN:
2357  0 case ORASSIGN:
2358  0 case XORASSIGN:
2359  0 case REMASSIGN:
2360  0 case LSHIFTASSIGN:
2361  0 case RSIGNEDSHIFTASSIGN:
2362  0 case RUNSIGNEDSHIFTASSIGN:
2363  789 AssignmentOperator();
2364  789 Expression();
2365  789 break;
2366  217108 default:
2367  217217 jj_la1[64] = jj_gen;
2368  217176 ;
2369    }
2370    } catch (Throwable jjte000) {
2371  0 if (jjtc000) {
2372  0 jjtree.clearNodeScope(jjtn000);
2373  0 jjtc000 = false;
2374    } else {
2375  0 jjtree.popNode();
2376    }
2377  0 if (jjte000 instanceof RuntimeException) {
2378  0 {if (true) throw (RuntimeException)jjte000;}
2379    }
2380  0 if (jjte000 instanceof ParseException) {
2381  0 {if (true) throw (ParseException)jjte000;}
2382    }
2383  0 {if (true) throw (Error)jjte000;}
2384    } finally {
2385  218014 if (jjtc000) {
2386  217989 jjtree.closeNodeScope(jjtn000, true);
2387    }
2388    }
2389    }
2390   
 
2391  15933 toggle final public void AssignmentOperator() throws ParseException {
2392    /*@bgen(jjtree) AssignmentOperator */
2393  15933 ASTAssignmentOperator jjtn000 = new ASTAssignmentOperator(this, JJTASSIGNMENTOPERATOR);
2394  15933 boolean jjtc000 = true;
2395  15933 jjtree.openNodeScope(jjtn000);
2396  15932 try {
2397  15933 switch (jj_nt.kind) {
2398  15120 case ASSIGN:
2399  15120 jj_consume_token(ASSIGN);
2400  15120 jjtree.closeNodeScope(jjtn000, true);
2401  15120 jjtc000 = false;
2402  15120 jjtn000.setImage("=");
2403  15120 break;
2404  30 case STARASSIGN:
2405  30 jj_consume_token(STARASSIGN);
2406  30 jjtree.closeNodeScope(jjtn000, true);
2407  30 jjtc000 = false;
2408  30 jjtn000.setImage("*="); jjtn000.setCompound();
2409  30 break;
2410  18 case SLASHASSIGN:
2411  18 jj_consume_token(SLASHASSIGN);
2412  18 jjtree.closeNodeScope(jjtn000, true);
2413  18 jjtc000 = false;
2414  18 jjtn000.setImage("/="); jjtn000.setCompound();
2415  18 break;
2416  18 case REMASSIGN:
2417  18 jj_consume_token(REMASSIGN);
2418  18 jjtree.closeNodeScope(jjtn000, true);
2419  18 jjtc000 = false;
2420  18 jjtn000.setImage("%="); jjtn000.setCompound();
2421  18 break;
2422  405 case PLUSASSIGN:
2423  405 jj_consume_token(PLUSASSIGN);
2424  405 jjtree.closeNodeScope(jjtn000, true);
2425  405 jjtc000 = false;
2426  405 jjtn000.setImage("+="); jjtn000.setCompound();
2427  405 break;
2428  36 case MINUSASSIGN:
2429  36 jj_consume_token(MINUSASSIGN);
2430  36 jjtree.closeNodeScope(jjtn000, true);
2431  36 jjtc000 = false;
2432  36 jjtn000.setImage("-="); jjtn000.setCompound();
2433  36 break;
2434  18 case LSHIFTASSIGN:
2435  18 jj_consume_token(LSHIFTASSIGN);
2436  18 jjtree.closeNodeScope(jjtn000, true);
2437  18 jjtc000 = false;
2438  18 jjtn000.setImage("<<="); jjtn000.setCompound();
2439  18 break;
2440  18 case RSIGNEDSHIFTASSIGN:
2441  18 jj_consume_token(RSIGNEDSHIFTASSIGN);
2442  18 jjtree.closeNodeScope(jjtn000, true);
2443  18 jjtc000 = false;
2444  18 jjtn000.setImage(">>="); jjtn000.setCompound();
2445  18 break;
2446  18 case RUNSIGNEDSHIFTASSIGN:
2447  18 jj_consume_token(RUNSIGNEDSHIFTASSIGN);
2448  18 jjtree.closeNodeScope(jjtn000, true);
2449  18 jjtc000 = false;
2450  18 jjtn000.setImage(">>>="); jjtn000.setCompound();
2451  18 break;
2452  177 case ANDASSIGN:
2453  177 jj_consume_token(ANDASSIGN);
2454  177 jjtree.closeNodeScope(jjtn000, true);
2455  177 jjtc000 = false;
2456  177 jjtn000.setImage("&="); jjtn000.setCompound();
2457  177 break;
2458  21 case XORASSIGN:
2459  21 jj_consume_token(XORASSIGN);
2460  21 jjtree.closeNodeScope(jjtn000, true);
2461  21 jjtc000 = false;
2462  21 jjtn000.setImage("^="); jjtn000.setCompound();
2463  21 break;
2464  54 case ORASSIGN:
2465  54 jj_consume_token(ORASSIGN);
2466  54 jjtree.closeNodeScope(jjtn000, true);
2467  54 jjtc000 = false;
2468  54 jjtn000.setImage("|="); jjtn000.setCompound();
2469  54 break;
2470  0 default:
2471  0 jj_la1[65] = jj_gen;
2472  0 jj_consume_token(-1);
2473  0 throw new ParseException();
2474    }
2475    } finally {
2476  15933 if (jjtc000) {
2477  0 jjtree.closeNodeScope(jjtn000, true);
2478    }
2479    }
2480    }
2481   
 
2482  219197 toggle final public void ConditionalExpression() throws ParseException {
2483    /*@bgen(jjtree) #ConditionalExpression(> 1) */
2484  219214 ASTConditionalExpression jjtn000 = new ASTConditionalExpression(this, JJTCONDITIONALEXPRESSION);
2485  219220 boolean jjtc000 = true;
2486  219203 jjtree.openNodeScope(jjtn000);
2487  219228 try {
2488  219229 ConditionalOrExpression();
2489  219073 switch (jj_nt.kind) {
2490  699 case HOOK:
2491  699 jj_consume_token(HOOK);
2492  699 jjtn000.setTernary();
2493  699 Expression();
2494  699 jj_consume_token(COLON);
2495  699 ConditionalExpression();
2496  699 break;
2497  218433 default:
2498  218486 jj_la1[66] = jj_gen;
2499  218489 ;
2500    }
2501    } catch (Throwable jjte000) {
2502  0 if (jjtc000) {
2503  0 jjtree.clearNodeScope(jjtn000);
2504  0 jjtc000 = false;
2505    } else {
2506  0 jjtree.popNode();
2507    }
2508  0 if (jjte000 instanceof RuntimeException) {
2509  0 {if (true) throw (RuntimeException)jjte000;}
2510    }
2511  0 if (jjte000 instanceof ParseException) {
2512  0 {if (true) throw (ParseException)jjte000;}
2513    }
2514  0 {if (true) throw (Error)jjte000;}
2515    } finally {
2516  219200 if (jjtc000) {
2517  219216 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2518    }
2519    }
2520    }
2521   
 
2522  219185 toggle final public void ConditionalOrExpression() throws ParseException {
2523    /*@bgen(jjtree) #ConditionalOrExpression(> 1) */
2524  219236 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
2525  219224 boolean jjtc000 = true;
2526  219220 jjtree.openNodeScope(jjtn000);
2527  219234 try {
2528  219233 ConditionalAndExpression();
2529  219084 label_28:
2530    while (true) {
2531  220805 switch (jj_nt.kind) {
2532  1638 case SC_OR:
2533  1638 ;
2534  1638 break;
2535  219185 default:
2536  219185 jj_la1[67] = jj_gen;
2537  219192 break label_28;
2538    }
2539  1638 jj_consume_token(SC_OR);
2540  1638 ConditionalAndExpression();
2541    }
2542    } catch (Throwable jjte000) {
2543  0 if (jjtc000) {
2544  0 jjtree.clearNodeScope(jjtn000);
2545  0 jjtc000 = false;
2546    } else {
2547  0 jjtree.popNode();
2548    }
2549  0 if (jjte000 instanceof RuntimeException) {
2550  0 {if (true) throw (RuntimeException)jjte000;}
2551    }
2552  0 if (jjte000 instanceof ParseException) {
2553  0 {if (true) throw (ParseException)jjte000;}
2554    }
2555  0 {if (true) throw (Error)jjte000;}
2556    } finally {
2557  219179 if (jjtc000) {
2558  219176 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2559    }
2560    }
2561    }
2562   
 
2563  220831 toggle final public void ConditionalAndExpression() throws ParseException {
2564    /*@bgen(jjtree) #ConditionalAndExpression(> 1) */
2565  220861 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
2566  220854 boolean jjtc000 = true;
2567  220864 jjtree.openNodeScope(jjtn000);
2568  220869 try {
2569  220870 InclusiveOrExpression();
2570  220699 label_29:
2571    while (true) {
2572  223219 switch (jj_nt.kind) {
2573  2415 case SC_AND:
2574  2415 ;
2575  2415 break;
2576  220818 default:
2577  220802 jj_la1[68] = jj_gen;
2578  220829 break label_29;
2579    }
2580  2415 jj_consume_token(SC_AND);
2581  2415 InclusiveOrExpression();
2582    }
2583    } catch (Throwable jjte000) {
2584  0 if (jjtc000) {
2585  0 jjtree.clearNodeScope(jjtn000);
2586  0 jjtc000 = false;
2587    } else {
2588  0 jjtree.popNode();
2589    }
2590  0 if (jjte000 instanceof RuntimeException) {
2591  0 {if (true) throw (RuntimeException)jjte000;}
2592    }
2593  0 if (jjte000 instanceof ParseException) {
2594  0 {if (true) throw (ParseException)jjte000;}
2595    }
2596  0 {if (true) throw (Error)jjte000;}
2597    } finally {
2598  220845 if (jjtc000) {
2599  220856 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2600    }
2601    }
2602    }
2603   
 
2604  223244 toggle final public void InclusiveOrExpression() throws ParseException {
2605    /*@bgen(jjtree) #InclusiveOrExpression(> 1) */
2606  223286 ASTInclusiveOrExpression jjtn000 = new ASTInclusiveOrExpression(this, JJTINCLUSIVEOREXPRESSION);
2607  223280 boolean jjtc000 = true;
2608  223277 jjtree.openNodeScope(jjtn000);
2609  223278 try {
2610  223276 ExclusiveOrExpression();
2611  223125 label_30:
2612    while (true) {
2613  223325 switch (jj_nt.kind) {
2614  60 case BIT_OR:
2615  60 ;
2616  60 break;
2617  223241 default:
2618  223243 jj_la1[69] = jj_gen;
2619  223227 break label_30;
2620    }
2621  60 jj_consume_token(BIT_OR);
2622  60 ExclusiveOrExpression();
2623    }
2624    } catch (Throwable jjte000) {
2625  0 if (jjtc000) {
2626  0 jjtree.clearNodeScope(jjtn000);
2627  0 jjtc000 = false;
2628    } else {
2629  0 jjtree.popNode();
2630    }
2631  0 if (jjte000 instanceof RuntimeException) {
2632  0 {if (true) throw (RuntimeException)jjte000;}
2633    }
2634  0 if (jjte000 instanceof ParseException) {
2635  0 {if (true) throw (ParseException)jjte000;}
2636    }
2637  0 {if (true) throw (Error)jjte000;}
2638    } finally {
2639  223274 if (jjtc000) {
2640  223255 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2641    }
2642    }
2643    }
2644   
 
2645  223293 toggle final public void ExclusiveOrExpression() throws ParseException {
2646    /*@bgen(jjtree) #ExclusiveOrExpression(> 1) */
2647  223341 ASTExclusiveOrExpression jjtn000 = new ASTExclusiveOrExpression(this, JJTEXCLUSIVEOREXPRESSION);
2648  223342 boolean jjtc000 = true;
2649  223341 jjtree.openNodeScope(jjtn000);
2650  223344 try {
2651  223341 AndExpression();
2652  223186 label_31:
2653    while (true) {
2654  223356 switch (jj_nt.kind) {
2655  36 case XOR:
2656  36 ;
2657  36 break;
2658  223221 default:
2659  223325 jj_la1[70] = jj_gen;
2660  223303 break label_31;
2661    }
2662  36 jj_consume_token(XOR);
2663  36 AndExpression();
2664    }
2665    } catch (Throwable jjte000) {
2666  0 if (jjtc000) {
2667  0 jjtree.clearNodeScope(jjtn000);
2668  0 jjtc000 = false;
2669    } else {
2670  0 jjtree.popNode();
2671    }
2672  0 if (jjte000 instanceof RuntimeException) {
2673  0 {if (true) throw (RuntimeException)jjte000;}
2674    }
2675  0 if (jjte000 instanceof ParseException) {
2676  0 {if (true) throw (ParseException)jjte000;}
2677    }
2678  0 {if (true) throw (Error)jjte000;}
2679    } finally {
2680  223297 if (jjtc000) {
2681  223289 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2682    }
2683    }
2684    }
2685   
 
2686  223322 toggle final public void AndExpression() throws ParseException {
2687    /*@bgen(jjtree) #AndExpression(> 1) */
2688  223376 ASTAndExpression jjtn000 = new ASTAndExpression(this, JJTANDEXPRESSION);
2689  223373 boolean jjtc000 = true;
2690  223370 jjtree.openNodeScope(jjtn000);
2691  223364 try {
2692  223384 EqualityExpression();
2693  223241 label_32:
2694    while (true) {
2695  225482 switch (jj_nt.kind) {
2696  2133 case BIT_AND:
2697  2133 ;
2698  2133 break;
2699  223295 default:
2700  223343 jj_la1[71] = jj_gen;
2701  223329 break label_32;
2702    }
2703  2133 jj_consume_token(BIT_AND);
2704  2133 EqualityExpression();
2705    }
2706    } catch (Throwable jjte000) {
2707  0 if (jjtc000) {
2708  0 jjtree.clearNodeScope(jjtn000);
2709  0 jjtc000 = false;
2710    } else {
2711  0 jjtree.popNode();
2712    }
2713  0 if (jjte000 instanceof RuntimeException) {
2714  0 {if (true) throw (RuntimeException)jjte000;}
2715    }
2716  0 if (jjte000 instanceof ParseException) {
2717  0 {if (true) throw (ParseException)jjte000;}
2718    }
2719  0 {if (true) throw (Error)jjte000;}
2720    } finally {
2721  223347 if (jjtc000) {
2722  223313 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2723    }
2724    }
2725    }
2726   
 
2727  225464 toggle final public void EqualityExpression() throws ParseException {
2728    /*@bgen(jjtree) #EqualityExpression(> 1) */
2729  225513 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
2730  225501 boolean jjtc000 = true;
2731  225505 jjtree.openNodeScope(jjtn000);
2732  225502 try {
2733  225505 InstanceOfExpression();
2734  225333 label_33:
2735    while (true) {
2736  234692 switch (jj_nt.kind) {
2737  4899 case EQ:
2738  4320 case NE:
2739  9219 ;
2740  9219 break;
2741  225405 default:
2742  225492 jj_la1[72] = jj_gen;
2743  225385 break label_33;
2744    }
2745  9219 switch (jj_nt.kind) {
2746  4899 case EQ:
2747  4899 jj_consume_token(EQ);
2748  4899 jjtn000.setImage("==");
2749  4899 break;
2750  4320 case NE:
2751  4320 jj_consume_token(NE);
2752  4320 jjtn000.setImage("!=");
2753  4320 break;
2754  0 default:
2755  0 jj_la1[73] = jj_gen;
2756  0 jj_consume_token(-1);
2757  0 throw new ParseException();
2758    }
2759  9219 InstanceOfExpression();
2760    }
2761    } catch (Throwable jjte000) {
2762  0 if (jjtc000) {
2763  0 jjtree.clearNodeScope(jjtn000);
2764  0 jjtc000 = false;
2765    } else {
2766  0 jjtree.popNode();
2767    }
2768  0 if (jjte000 instanceof RuntimeException) {
2769  0 {if (true) throw (RuntimeException)jjte000;}
2770    }
2771  0 if (jjte000 instanceof ParseException) {
2772  0 {if (true) throw (ParseException)jjte000;}
2773    }
2774  0 {if (true) throw (Error)jjte000;}
2775    } finally {
2776  225468 if (jjtc000) {
2777  225473 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2778    }
2779    }
2780    }
2781   
 
2782  234658 toggle final public void InstanceOfExpression() throws ParseException {
2783    /*@bgen(jjtree) #InstanceOfExpression(> 1) */
2784  234679 ASTInstanceOfExpression jjtn000 = new ASTInstanceOfExpression(this, JJTINSTANCEOFEXPRESSION);
2785  234716 boolean jjtc000 = true;
2786  234725 jjtree.openNodeScope(jjtn000);
2787  234718 try {
2788  234727 RelationalExpression();
2789  234549 switch (jj_nt.kind) {
2790  2667 case INSTANCEOF:
2791  2666 jj_consume_token(INSTANCEOF);
2792  2667 Type();
2793  2667 break;
2794  231943 default:
2795  232045 jj_la1[74] = jj_gen;
2796  232034 ;
2797    }
2798    } catch (Throwable jjte000) {
2799  0 if (jjtc000) {
2800  0 jjtree.clearNodeScope(jjtn000);
2801  0 jjtc000 = false;
2802    } else {
2803  0 jjtree.popNode();
2804    }
2805  0 if (jjte000 instanceof RuntimeException) {
2806  0 {if (true) throw (RuntimeException)jjte000;}
2807    }
2808  0 if (jjte000 instanceof ParseException) {
2809  0 {if (true) throw (ParseException)jjte000;}
2810    }
2811  0 {if (true) throw (Error)jjte000;}
2812    } finally {
2813  234698 if (jjtc000) {
2814  234685 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2815    }
2816    }
2817    }
2818   
 
2819  234647 toggle final public void RelationalExpression() throws ParseException {
2820    /*@bgen(jjtree) #RelationalExpression(> 1) */
2821  234722 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
2822  234717 boolean jjtc000 = true;
2823  234707 jjtree.openNodeScope(jjtn000);
2824  234721 try {
2825  234729 ShiftExpression();
2826  234462 label_34:
2827    while (true) {
2828  238444 switch (jj_nt.kind) {
2829  1962 case LT:
2830  138 case LE:
2831  357 case GE:
2832  1443 case GT:
2833  3900 ;
2834  3900 break;
2835  234607 default:
2836  234682 jj_la1[75] = jj_gen;
2837  234659 break label_34;
2838    }
2839  3900 switch (jj_nt.kind) {
2840  1962 case LT:
2841  1962 jj_consume_token(LT);
2842  1962 jjtn000.setImage("<");
2843  1962 break;
2844  1443 case GT:
2845  1443 jj_consume_token(GT);
2846  1443 jjtn000.setImage(">");
2847  1443 break;
2848  138 case LE:
2849  138 jj_consume_token(LE);
2850  138 jjtn000.setImage("<=");
2851  138 break;
2852  357 case GE:
2853  357 jj_consume_token(GE);
2854  357 jjtn000.setImage(">=");
2855  357 break;
2856  0 default:
2857  0 jj_la1[76] = jj_gen;
2858  0 jj_consume_token(-1);
2859  0 throw new ParseException();
2860    }
2861  3900 ShiftExpression();
2862    }
2863    } catch (Throwable jjte000) {
2864  0 if (jjtc000) {
2865  0 jjtree.clearNodeScope(jjtn000);
2866  0 jjtc000 = false;
2867    } else {
2868  0 jjtree.popNode();
2869    }
2870  0 if (jjte000 instanceof RuntimeException) {
2871  0 {if (true) throw (RuntimeException)jjte000;}
2872    }
2873  0 if (jjte000 instanceof ParseException) {
2874  0 {if (true) throw (ParseException)jjte000;}
2875    }
2876  0 {if (true) throw (Error)jjte000;}
2877    } finally {
2878  234690 if (jjtc000) {
2879  234713 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2880    }
2881    }
2882    }
2883   
 
2884  238537 toggle final public void ShiftExpression() throws ParseException {
2885    /*@bgen(jjtree) #ShiftExpression(> 1) */
2886  238608 ASTShiftExpression jjtn000 = new ASTShiftExpression(this, JJTSHIFTEXPRESSION);
2887  238622 boolean jjtc000 = true;
2888  238629 jjtree.openNodeScope(jjtn000);
2889  238622 try {
2890  238622 AdditiveExpression();
2891  238522 label_35:
2892    while (true) {
2893  239094 if (jj_2_22(1)) {
2894  522 ;
2895    } else {
2896  238498 break label_35;
2897    }
2898  522 switch (jj_nt.kind) {
2899  297 case LSHIFT:
2900  297 jj_consume_token(LSHIFT);
2901  297 jjtn000.setImage("<<");
2902  297 break;
2903  225 default:
2904  225 jj_la1[77] = jj_gen;
2905  225 if (jj_2_23(1)) {
2906  207 RSIGNEDSHIFT();
2907  18 } else if (jj_2_24(1)) {
2908  18 RUNSIGNEDSHIFT();
2909    } else {
2910  0 jj_consume_token(-1);
2911  0 throw new ParseException();
2912    }
2913    }
2914  522 AdditiveExpression();
2915    }
2916    } catch (Throwable jjte000) {
2917  0 if (jjtc000) {
2918  0 jjtree.clearNodeScope(jjtn000);
2919  0 jjtc000 = false;
2920    } else {
2921  0 jjtree.popNode();
2922    }
2923  0 if (jjte000 instanceof RuntimeException) {
2924  0 {if (true) throw (RuntimeException)jjte000;}
2925    }
2926  0 if (jjte000 instanceof ParseException) {
2927  0 {if (true) throw (ParseException)jjte000;}
2928    }
2929  0 {if (true) throw (Error)jjte000;}
2930    } finally {
2931  238584 if (jjtc000) {
2932  238607 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2933    }
2934    }
2935    }
2936   
 
2937  239052 toggle final public void AdditiveExpression() throws ParseException {
2938    /*@bgen(jjtree) #AdditiveExpression(> 1) */
2939  239150 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
2940  239108 boolean jjtc000 = true;
2941  239144 jjtree.openNodeScope(jjtn000);
2942  239137 try {
2943  239132 MultiplicativeExpression();
2944  239073 label_36:
2945    while (true) {
2946  256262 switch (jj_nt.kind) {
2947  15962 case PLUS:
2948  1164 case MINUS:
2949  17126 ;
2950  17127 break;
2951  239062 default:
2952  239147 jj_la1[78] = jj_gen;
2953  239128 break label_36;
2954    }
2955  17125 switch (jj_nt.kind) {
2956  15961 case PLUS:
2957  15963 jj_consume_token(PLUS);
2958  15962 jjtn000.setImage("+");
2959  15963 break;
2960  1164 case MINUS:
2961  1164 jj_consume_token(MINUS);
2962  1164 jjtn000.setImage("-");
2963  1164 break;
2964  0 default:
2965  0 jj_la1[79] = jj_gen;
2966  0 jj_consume_token(-1);
2967  0 throw new ParseException();
2968    }
2969  17126 MultiplicativeExpression();
2970    }
2971    } catch (Throwable jjte000) {
2972  0 if (jjtc000) {
2973  0 jjtree.clearNodeScope(jjtn000);
2974  0 jjtc000 = false;
2975    } else {
2976  0 jjtree.popNode();
2977    }
2978  0 if (jjte000 instanceof RuntimeException) {
2979  0 {if (true) throw (RuntimeException)jjte000;}
2980    }
2981  0 if (jjte000 instanceof ParseException) {
2982  0 {if (true) throw (ParseException)jjte000;}
2983    }
2984  0 {if (true) throw (Error)jjte000;}
2985    } finally {
2986  239129 if (jjtc000) {
2987  239103 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
2988    }
2989    }
2990    }
2991   
 
2992  256173 toggle final public void MultiplicativeExpression() throws ParseException {
2993    /*@bgen(jjtree) #MultiplicativeExpression(> 1) */
2994  256250 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
2995  256251 boolean jjtc000 = true;
2996  256216 jjtree.openNodeScope(jjtn000);
2997  256270 try {
2998  256265 UnaryExpression();
2999  256216 label_37:
3000    while (true) {
3001  256676 switch (jj_nt.kind) {
3002  213 case STAR:
3003  153 case SLASH:
3004  81 case REM:
3005  447 ;
3006  447 break;
3007  256211 default:
3008  256254 jj_la1[80] = jj_gen;
3009  256220 break label_37;
3010    }
3011  447 switch (jj_nt.kind) {
3012  213 case STAR:
3013  213 jj_consume_token(STAR);
3014  213 jjtn000.setImage("*");
3015  213 break;
3016  153 case SLASH:
3017  153 jj_consume_token(SLASH);
3018  153 jjtn000.setImage("/");
3019  153 break;
3020  81 case REM:
3021  81 jj_consume_token(REM);
3022  81 jjtn000.setImage("%");
3023  81 break;
3024  0 default:
3025  0 jj_la1[81] = jj_gen;
3026  0 jj_consume_token(-1);
3027  0 throw new ParseException();
3028    }
3029  447 UnaryExpression();
3030    }
3031    } catch (Throwable jjte000) {
3032  0 if (jjtc000) {
3033  0 jjtree.clearNodeScope(jjtn000);
3034  0 jjtc000 = false;
3035    } else {
3036  0 jjtree.popNode();
3037    }
3038  0 if (jjte000 instanceof RuntimeException) {
3039  0 {if (true) throw (RuntimeException)jjte000;}
3040    }
3041  0 if (jjte000 instanceof ParseException) {
3042  0 {if (true) throw (ParseException)jjte000;}
3043    }
3044  0 {if (true) throw (Error)jjte000;}
3045    } finally {
3046  256252 if (jjtc000) {
3047  256232 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3048    }
3049    }
3050    }
3051   
 
3052  263834 toggle final public void UnaryExpression() throws ParseException {
3053    /*@bgen(jjtree) #UnaryExpression( ( jjtn000 . getImage ( ) != null )) */
3054  263850 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
3055  263930 boolean jjtc000 = true;
3056  263935 jjtree.openNodeScope(jjtn000);
3057  263929 try {
3058  263926 switch (jj_nt.kind) {
3059  144 case PLUS:
3060  1989 case MINUS:
3061  2133 switch (jj_nt.kind) {
3062  144 case PLUS:
3063  144 jj_consume_token(PLUS);
3064  144 jjtn000.setImage("+");
3065  144 break;
3066  1989 case MINUS:
3067  1989 jj_consume_token(MINUS);
3068  1989 jjtn000.setImage("-");
3069  1989 break;
3070  0 default:
3071  0 jj_la1[82] = jj_gen;
3072  0 jj_consume_token(-1);
3073  0 throw new ParseException();
3074    }
3075  2133 UnaryExpression();
3076  2133 break;
3077  129 case INCR:
3078  129 PreIncrementExpression();
3079  129 break;
3080  192 case DECR:
3081  192 PreDecrementExpression();
3082  192 break;
3083  6 case BOOLEAN:
3084  9 case BYTE:
3085  6 case CHAR:
3086  6 case DOUBLE:
3087  3987 case FALSE:
3088  9 case FLOAT:
3089  12 case INT:
3090  9 case LONG:
3091  13394 case NEW:
3092  5433 case NULL:
3093  6 case SHORT:
3094  1074 case SUPER:
3095  2437 case THIS:
3096  7470 case TRUE:
3097  9 case VOID:
3098  45540 case INTEGER_LITERAL:
3099  1596 case FLOATING_POINT_LITERAL:
3100  225 case HEX_FLOATING_POINT_LITERAL:
3101  1782 case CHARACTER_LITERAL:
3102  29298 case STRING_LITERAL:
3103  132276 case IDENTIFIER:
3104  14498 case LPAREN:
3105  2307 case BANG:
3106  45 case TILDE:
3107  261442 UnaryExpressionNotPlusMinus();
3108  261427 break;
3109  0 default:
3110  0 jj_la1[83] = jj_gen;
3111  0 jj_consume_token(-1);
3112  0 throw new ParseException();
3113    }
3114    } catch (Throwable jjte000) {
3115  0 if (jjtc000) {
3116  0 jjtree.clearNodeScope(jjtn000);
3117  0 jjtc000 = false;
3118    } else {
3119  0 jjtree.popNode();
3120    }
3121  0 if (jjte000 instanceof RuntimeException) {
3122  0 {if (true) throw (RuntimeException)jjte000;}
3123    }
3124  0 if (jjte000 instanceof ParseException) {
3125  0 {if (true) throw (ParseException)jjte000;}
3126    }
3127  0 {if (true) throw (Error)jjte000;}
3128    } finally {
3129  263915 if (jjtc000) {
3130  263943 jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3131    }
3132    }
3133    }
3134   
 
3135  234 toggle final public void PreIncrementExpression() throws ParseException {
3136    /*@bgen(jjtree) PreIncrementExpression */
3137  234 ASTPreIncrementExpression jjtn000 = new ASTPreIncrementExpression(this, JJTPREINCREMENTEXPRESSION);
3138  234 boolean jjtc000 = true;
3139  234 jjtree.openNodeScope(jjtn000);
3140  234 try {
3141  234 jj_consume_token(INCR);
3142  234 PrimaryExpression();
3143    } catch (Throwable jjte000) {
3144  0 if (jjtc000) {
3145  0 jjtree.clearNodeScope(jjtn000);
3146  0 jjtc000 = false;
3147    } else {
3148  0 jjtree.popNode();
3149    }
3150  0 if (jjte000 instanceof RuntimeException) {
3151  0 {if (true) throw (RuntimeException)jjte000;}
3152    }
3153  0 if (jjte000 instanceof ParseException) {
3154  0 {if (true) throw (ParseException)jjte000;}
3155    }
3156  0 {if (true) throw (Error)jjte000;}
3157    } finally {
3158  234 if (jjtc000) {
3159  234 jjtree.closeNodeScope(jjtn000, true);
3160    }
3161    }
3162    }
3163   
 
3164  228 toggle final public void PreDecrementExpression() throws ParseException {
3165    /*@bgen(jjtree) PreDecrementExpression */
3166  228 ASTPreDecrementExpression jjtn000 = new ASTPreDecrementExpression(this, JJTPREDECREMENTEXPRESSION);
3167  228 boolean jjtc000 = true;
3168  228 jjtree.openNodeScope(jjtn000);
3169  228 try {
3170  228 jj_consume_token(DECR);
3171  228 PrimaryExpression();
3172    } catch (Throwable jjte000) {
3173  0 if (jjtc000) {
3174  0 jjtree.clearNodeScope(jjtn000);
3175  0 jjtc000 = false;
3176    } else {
3177  0 jjtree.popNode();
3178    }
3179  0 if (jjte000 instanceof RuntimeException) {
3180  0 {if (true) throw (RuntimeException)jjte000;}
3181    }
3182  0 if (jjte000 instanceof ParseException) {
3183  0 {if (true) throw (ParseException)jjte000;}
3184    }
3185  0 {if (true) throw (Error)jjte000;}
3186    } finally {
3187  228 if (jjtc000) {
3188  228 jjtree.closeNodeScope(jjtn000, true);
3189    }
3190    }
3191    }
3192   
 
3193  266628 toggle final public void UnaryExpressionNotPlusMinus() throws ParseException {
3194    /*@bgen(jjtree) #UnaryExpressionNotPlusMinus( ( jjtn000 . getImage ( ) != null )) */
3195  266716 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
3196  266725 boolean jjtc000 = true;
3197  266737 jjtree.openNodeScope(jjtn000);
3198  266746 try {
3199  266742 switch (jj_nt.kind) {
3200  2307 case BANG:
3201  45 case TILDE:
3202  2352 switch (jj_nt.kind) {
3203  45 case TILDE:
3204  45 jj_consume_token(TILDE);
3205  45 jjtn000.setImage("~");
3206  45 break;
3207  2307 case BANG:
3208  2307 jj_consume_token(BANG);
3209  2307 jjtn000.setImage("!");
3210  2307 break;
3211  0 default:
3212  0 jj_la1[84] = jj_gen;
3213  0 jj_consume_token(-1);
3214  0 throw new ParseException();
3215    }
3216  2352 UnaryExpression();
3217  2352 break;
3218  264299 default:
3219  264359 jj_la1[85] = jj_gen;
3220  264375 if (jj_2_25(2147483647)) {
3221  7998 CastExpression();
3222    } else {
3223  256357 switch (jj_nt.kind) {
3224  6 case BOOLEAN:
3225  9 case BYTE:
3226  6 case CHAR:
3227  6 case DOUBLE:
3228  3987 case FALSE:
3229  9 case FLOAT:
3230  12 case INT:
3231  9 case LONG:
3232  13395 case NEW:
3233  5460 case NULL:
3234  6 case SHORT:
3235  1074 case SUPER:
3236  2449 case THIS:
3237  7470 case TRUE:
3238  9 case VOID:
3239  45537 case INTEGER_LITERAL:
3240  1596 case FLOATING_POINT_LITERAL:
3241  225 case HEX_FLOATING_POINT_LITERAL:
3242  1782 case CHARACTER_LITERAL:
3243  29300 case STRING_LITERAL:
3244  137404 case IDENTIFIER:
3245  6591 case LPAREN:
3246  256385 PostfixExpression();
3247  256297 break;
3248  0 default:
3249  0 jj_la1[86] = jj_gen;
3250  0 jj_consume_token(-1);
3251  0 throw new ParseException();
3252    }
3253    }
3254    }
3255    } catch (Throwable jjte000) {
3256  0 if (jjtc000) {
3257  0 jjtree.clearNodeScope(jjtn000);
3258  0 jjtc000 = false;
3259    } else {
3260  0 jjtree.popNode();
3261    }
3262  0 if (jjte000 instanceof RuntimeException) {
3263  0 {if (true) throw (RuntimeException)jjte000;}
3264    }
3265  0 if (jjte000 instanceof ParseException) {
3266  0 {if (true) throw (ParseException)jjte000;}
3267    }
3268  0 {if (true) throw (Error)jjte000;}
3269    } finally {
3270  266737 if (jjtc000) {
3271  266746 jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3272    }
3273    }
3274    }
3275   
3276    // This production is to determine lookahead only. The LOOKAHEAD specifications
3277    // below are not used, but they are there just to indicate that we know about
3278    // this.
 
3279  0 toggle final public void CastLookahead() throws ParseException {
3280  0 if (jj_2_26(3)) {
3281  0 jj_consume_token(LPAREN);
3282  0 PrimitiveType();
3283  0 jj_consume_token(RPAREN);
3284  0 } else if (jj_2_27(2147483647)) {
3285  0 jj_consume_token(LPAREN);
3286  0 Type();
3287  0 jj_consume_token(LBRACKET);
3288  0 jj_consume_token(RBRACKET);
3289    } else {
3290  0 switch (jj_nt.kind) {
3291  0 case LPAREN:
3292  0 jj_consume_token(LPAREN);
3293  0 Type();
3294  0 jj_consume_token(RPAREN);
3295  0 switch (jj_nt.kind) {
3296  0 case TILDE:
3297  0 jj_consume_token(TILDE);
3298  0 break;
3299  0 case BANG:
3300  0 jj_consume_token(BANG);
3301  0 break;
3302  0 case LPAREN:
3303  0 jj_consume_token(LPAREN);
3304  0 break;
3305  0 case IDENTIFIER:
3306  0 jj_consume_token(IDENTIFIER);
3307  0 break;
3308  0 case THIS:
3309  0 jj_consume_token(THIS);
3310  0 break;
3311  0 case SUPER:
3312  0 jj_consume_token(SUPER);
3313  0 break;
3314  0 case NEW:
3315  0 jj_consume_token(NEW);
3316  0 break;
3317  0 case FALSE:
3318  0 case NULL:
3319  0 case TRUE:
3320  0 case INTEGER_LITERAL:
3321  0 case FLOATING_POINT_LITERAL:
3322  0 case HEX_FLOATING_POINT_LITERAL:
3323  0 case CHARACTER_LITERAL:
3324  0 case STRING_LITERAL:
3325  0 Literal();
3326  0 break;
3327  0 default:
3328  0 jj_la1[87] = jj_gen;
3329  0 jj_consume_token(-1);
3330  0 throw new ParseException();
3331    }
3332  0 break;
3333  0 default:
3334  0 jj_la1[88] = jj_gen;
3335  0 jj_consume_token(-1);
3336  0 throw new ParseException();
3337    }
3338    }
3339    }
3340   
 
3341  258114 toggle final public void PostfixExpression() throws ParseException {
3342    /*@bgen(jjtree) #PostfixExpression( ( jjtn000 . getImage ( ) != null )) */
3343  258237 ASTPostfixExpression jjtn000 = new ASTPostfixExpression(this, JJTPOSTFIXEXPRESSION);
3344  258245 boolean jjtc000 = true;
3345  258253 jjtree.openNodeScope(jjtn000);
3346  258214 try {
3347  258251 PrimaryExpression();
3348  258211 switch (jj_nt.kind) {
3349  2589 case INCR:
3350  117 case DECR:
3351  2706 switch (jj_nt.kind) {
3352  2589 case INCR:
3353  2589 jj_consume_token(INCR);
3354  2589 jjtn000.setImage("++");
3355  2589 break;
3356  117 case DECR:
3357  117 jj_consume_token(DECR);
3358  117 jjtn000.setImage("--");
3359  117 break;
3360  0 default:
3361  0 jj_la1[89] = jj_gen;
3362  0 jj_consume_token(-1);
3363  0 throw new ParseException();
3364    }
3365  2706 break;
3366  255435 default:
3367  255537 jj_la1[90] = jj_gen;
3368  255513 ;
3369    }
3370    } catch (Throwable jjte000) {
3371  0 if (jjtc000) {
3372  0 jjtree.clearNodeScope(jjtn000);
3373  0 jjtc000 = false;
3374    } else {
3375  0 jjtree.popNode();
3376    }
3377  0 if (jjte000 instanceof RuntimeException) {
3378  0 {if (true) throw (RuntimeException)jjte000;}
3379    }
3380  0 if (jjte000 instanceof ParseException) {
3381  0 {if (true) throw (ParseException)jjte000;}
3382    }
3383  0 {if (true) throw (Error)jjte000;}
3384    } finally {
3385  258267 if (jjtc000) {
3386  258228 jjtree.closeNodeScope(jjtn000, ( jjtn000 . getImage ( ) != null ));
3387    }
3388    }
3389    }
3390   
 
3391  7998 toggle final public void CastExpression() throws ParseException {
3392    /*@bgen(jjtree) #CastExpression(> 1) */
3393  7998 ASTCastExpression jjtn000 = new ASTCastExpression(this, JJTCASTEXPRESSION);
3394  7998 boolean jjtc000 = true;
3395  7998 jjtree.openNodeScope(jjtn000);
3396  7998 try {
3397  7998 if (jj_2_28(2147483647)) {
3398  2736 jj_consume_token(LPAREN);
3399  2736 Type();
3400  2736 jj_consume_token(RPAREN);
3401  2736 UnaryExpression();
3402    } else {
3403  5262 switch (jj_nt.kind) {
3404  5262 case LPAREN:
3405  5262 jj_consume_token(LPAREN);
3406  5262 Type();
3407  5262 jj_consume_token(RPAREN);
3408  5262 UnaryExpressionNotPlusMinus();
3409  5262 break;
3410  0 default:
3411  0 jj_la1[91] = jj_gen;
3412  0 jj_consume_token(-1);
3413  0 throw new ParseException();
3414    }
3415    }
3416    } catch (Throwable jjte000) {
3417  0 if (jjtc000) {
3418  0 jjtree.clearNodeScope(jjtn000);
3419  0 jjtc000 = false;
3420    } else {
3421  0 jjtree.popNode();
3422    }
3423  0 if (jjte000 instanceof RuntimeException) {
3424  0 {if (true) throw (RuntimeException)jjte000;}
3425    }
3426  0 if (jjte000 instanceof ParseException) {
3427  0 {if (true) throw (ParseException)jjte000;}
3428    }
3429  0 {if (true) throw (Error)jjte000;}
3430    } finally {
3431  7998 if (jjtc000) {
3432  7998 jjtree.closeNodeScope(jjtn000, jjtree.nodeArity() > 1);
3433    }
3434    }
3435    }
3436   
 
3437  305643 toggle final public void PrimaryExpression() throws ParseException {
3438    /*@bgen(jjtree) PrimaryExpression */
3439  305809 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
3440  305830 boolean jjtc000 = true;
3441  305798 jjtree.openNodeScope(jjtn000);
3442  305821 try {
3443  305813 PrimaryPrefix();
3444  305830 label_38:
3445    while (true) {
3446  407545 if (jj_2_29(2)) {
3447  101784 ;
3448    } else {
3449  305763 break label_38;
3450    }
3451  101768 PrimarySuffix();
3452    }
3453    } catch (Throwable jjte000) {
3454  0 if (jjtc000) {
3455  0 jjtree.clearNodeScope(jjtn000);
3456  0 jjtc000 = false;
3457    } else {
3458  0 jjtree.popNode();
3459    }
3460  0 if (jjte000 instanceof RuntimeException) {
3461  0 {if (true) throw (RuntimeException)jjte000;}
3462    }
3463  0 if (jjte000 instanceof ParseException) {
3464  0 {if (true) throw (ParseException)jjte000;}
3465    }
3466  0 {if (true) throw (Error)jjte000;}
3467    } finally {
3468  305789 if (jjtc000) {
3469  305812 jjtree.closeNodeScope(jjtn000, true);
3470    }
3471    }
3472    }
3473   
 
3474  27 toggle final public void MemberSelector() throws ParseException {
3475    /*@bgen(jjtree) MemberSelector */
3476  27 ASTMemberSelector jjtn000 = new ASTMemberSelector(this, JJTMEMBERSELECTOR);
3477  27 boolean jjtc000 = true;
3478  27 jjtree.openNodeScope(jjtn000);Token t;
3479  27 try {
3480  27 jj_consume_token(DOT);
3481  27 TypeArguments();
3482  27 t = jj_consume_token(IDENTIFIER);
3483  27 jjtree.closeNodeScope(jjtn000, true);
3484  27 jjtc000 = false;
3485  27 jjtn000.setImage(t.image);
3486    } catch (Throwable jjte000) {
3487  0 if (jjtc000) {
3488  0 jjtree.clearNodeScope(jjtn000);
3489  0 jjtc000 = false;
3490    } else {
3491  0 jjtree.popNode();
3492    }
3493  0 if (jjte000 instanceof RuntimeException) {
3494  0 {if (true) throw (RuntimeException)jjte000;}
3495    }
3496  0 if (jjte000 instanceof ParseException) {
3497  0 {if (true) throw (ParseException)jjte000;}
3498    }
3499  0 {if (true) throw (Error)jjte000;}
3500    } finally {
3501  27 if (jjtc000) {
3502  0 jjtree.closeNodeScope(jjtn000, true);
3503    }
3504    }
3505    }
3506   
 
3507  305676 toggle final public void PrimaryPrefix() throws ParseException {
3508    /*@bgen(jjtree) PrimaryPrefix */
3509  305777 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
3510  305815 boolean jjtc000 = true;
3511  305849 jjtree.openNodeScope(jjtn000);Token t;
3512  305864 try {
3513  305851 switch (jj_nt.kind) {
3514  3987 case FALSE:
3515  5463 case NULL:
3516  7473 case TRUE:
3517  45542 case INTEGER_LITERAL:
3518  1596 case FLOATING_POINT_LITERAL:
3519  225 case HEX_FLOATING_POINT_LITERAL:
3520  1782 case CHARACTER_LITERAL:
3521  29304 case STRING_LITERAL:
3522  95370 Literal();
3523  95370 break;
3524  4851 case THIS:
3525  4851 jj_consume_token(THIS);
3526  4849 jjtree.closeNodeScope(jjtn000, true);
3527  4850 jjtc000 = false;
3528  4851 jjtn000.setUsesThisModifier();
3529  4851 break;
3530  1656 case SUPER:
3531  1656 jj_consume_token(SUPER);
3532  1656 jjtn000.setUsesSuperModifier();
3533  1656 jj_consume_token(DOT);
3534  1656 t = jj_consume_token(IDENTIFIER);
3535  1656 jjtree.closeNodeScope(jjtn000, true);
3536  1656 jjtc000 = false;
3537  1656 jjtn000.setImage(t.image);
3538  1656 break;
3539  6678 case LPAREN:
3540  6678 jj_consume_token(LPAREN);
3541  6678 Expression();
3542  6678 jj_consume_token(RPAREN);
3543  6678 break;
3544  13541 case NEW:
3545  13541 AllocationExpression();
3546  13542 break;
3547  183698 default:
3548  183745 jj_la1[92] = jj_gen;
3549  183746 if (jj_2_30(2147483647)) {
3550  3780 ResultType();
3551  3780 jj_consume_token(DOT);
3552  3780 jj_consume_token(CLASS);
3553    } else {
3554  179959 switch (jj_nt.kind) {
3555  179974 case IDENTIFIER:
3556  179951 Name();
3557  179982 break;
3558  0 default:
3559  0 jj_la1[93] = jj_gen;
3560  0 jj_consume_token(-1);
3561  0 throw new ParseException();
3562    }
3563    }
3564    }
3565    } catch (Throwable jjte000) {
3566  0 if (jjtc000) {
3567  0 jjtree.clearNodeScope(jjtn000);
3568  0 jjtc000 = false;
3569    } else {
3570  0 jjtree.popNode();
3571    }
3572  0 if (jjte000 instanceof RuntimeException) {
3573  0 {if (true) throw (RuntimeException)jjte000;}
3574    }
3575  0 if (jjte000 instanceof ParseException) {
3576  0 {if (true) throw (ParseException)jjte000;}
3577    }
3578  0 {if (true) throw (Error)jjte000;}
3579    } finally {
3580  305856 if (jjtc000) {
3581  299355 jjtree.closeNodeScope(jjtn000, true);
3582    }
3583    }
3584    }
3585   
 
3586  101766 toggle final public void PrimarySuffix() throws ParseException {
3587    /*@bgen(jjtree) PrimarySuffix */
3588  101784 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
3589  101786 boolean jjtc000 = true;
3590  101776 jjtree.openNodeScope(jjtn000);Token t;
3591  101781 try {
3592  101789 if (jj_2_31(2)) {
3593  12 jj_consume_token(DOT);
3594  12 jj_consume_token(THIS);
3595  101787 } else if (jj_2_32(2)) {
3596  0 jj_consume_token(DOT);
3597  0 jj_consume_token(SUPER);
3598  101787 } else if (jj_2_33(2)) {
3599  0 jj_consume_token(DOT);
3600  0 AllocationExpression();
3601  101787 } else if (jj_2_34(3)) {
3602  27 MemberSelector();
3603    } else {
3604  101750 switch (jj_nt.kind) {
3605  3102 case LBRACKET:
3606  3102 jj_consume_token(LBRACKET);
3607  3102 Expression();
3608  3102 jj_consume_token(RBRACKET);
3609  3102 jjtree.closeNodeScope(jjtn000, true);
3610  3102 jjtc000 = false;
3611  3102 jjtn000.setIsArrayDereference();
3612  3102 break;
3613  12720 case DOT:
3614  12720 jj_consume_token(DOT);
3615  12719 t = jj_consume_token(IDENTIFIER);
3616  12719 jjtree.closeNodeScope(jjtn000, true);
3617  12720 jjtc000 = false;
3618  12720 jjtn000.setImage(t.image);
3619  12720 break;
3620  85895 case LPAREN:
3621  85921 Arguments();
3622  85930 jjtree.closeNodeScope(jjtn000, true);
3623  85940 jjtc000 = false;
3624  85937 jjtn000.setIsArguments();
3625  85937 break;
3626  0 default:
3627  0 jj_la1[94] = jj_gen;
3628  0 jj_consume_token(-1);
3629  0 throw new ParseException();
3630    }
3631    }
3632    } catch (Throwable jjte000) {
3633  0 if (jjtc000) {
3634  0 jjtree.clearNodeScope(jjtn000);
3635  0 jjtc000 = false;
3636    } else {
3637  0 jjtree.popNode();
3638    }
3639  0 if (jjte000 instanceof RuntimeException) {
3640  0 {if (true) throw (RuntimeException)jjte000;}
3641    }
3642  0 if (jjte000 instanceof ParseException) {
3643  0 {if (true) throw (ParseException)jjte000;}
3644    }
3645  0 {if (true) throw (Error)jjte000;}
3646    } finally {
3647  101796 if (jjtc000) {
3648  39 jjtree.closeNodeScope(jjtn000, true);
3649    }
3650    }
3651    }
3652   
 
3653  95341 toggle final public void Literal() throws ParseException {
3654    /*@bgen(jjtree) Literal */
3655  95357 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
3656  95368 boolean jjtc000 = true;
3657  95363 jjtree.openNodeScope(jjtn000);
3658  95372 try {
3659  95376 switch (jj_nt.kind) {
3660  45542 case INTEGER_LITERAL:
3661  45538 Token t;
3662  45541 t = jj_consume_token(INTEGER_LITERAL);
3663  45542 jjtree.closeNodeScope(jjtn000, true);
3664  45541 jjtc000 = false;
3665  45540 checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setIntLiteral();
3666  45542 break;
3667  1596 case FLOATING_POINT_LITERAL:
3668  1596 t = jj_consume_token(FLOATING_POINT_LITERAL);
3669  1596 jjtree.closeNodeScope(jjtn000, true);
3670  1596 jjtc000 = false;
3671  1596 checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
3672  1596 break;
3673  225 case HEX_FLOATING_POINT_LITERAL:
3674  225 t = jj_consume_token(HEX_FLOATING_POINT_LITERAL);
3675  225 jjtree.closeNodeScope(jjtn000, true);
3676  225 jjtc000 = false;
3677  225 checkForBadHexFloatingPointLiteral(); checkForBadNumericalLiteralslUsage(t); jjtn000.setImage(t.image); jjtn000.setFloatLiteral();
3678  225 break;
3679  1782 case CHARACTER_LITERAL:
3680  1782 t = jj_consume_token(CHARACTER_LITERAL);
3681  1782 jjtree.closeNodeScope(jjtn000, true);
3682  1782 jjtc000 = false;
3683  1782 jjtn000.setImage(t.image); jjtn000.setCharLiteral();
3684  1782 break;
3685  29296 case STRING_LITERAL:
3686  29302 t = jj_consume_token(STRING_LITERAL);
3687  29302 jjtree.closeNodeScope(jjtn000, true);
3688  29307 jjtc000 = false;
3689  29301 jjtn000.setImage(t.image); jjtn000.setStringLiteral();
3690  29304 break;
3691  3987 case FALSE:
3692  7473 case TRUE:
3693  11460 BooleanLiteral();
3694  11460 break;
3695  5463 case NULL:
3696  5463 NullLiteral();
3697  5463 break;
3698  0 default:
3699  0 jj_la1[95] = jj_gen;
3700  0 jj_consume_token(-1);
3701  0 throw new ParseException();
3702    }
3703    } catch (Throwable jjte000) {
3704  0 if (jjtc000) {
3705  0 jjtree.clearNodeScope(jjtn000);
3706  0 jjtc000 = false;
3707    } else {
3708  0 jjtree.popNode();
3709    }
3710  0 if (jjte000 instanceof RuntimeException) {
3711  0 {if (true) throw (RuntimeException)jjte000;}
3712    }
3713  0 if (jjte000 instanceof ParseException) {
3714  0 {if (true) throw (ParseException)jjte000;}
3715    }
3716  0 {if (true) throw (Error)jjte000;}
3717    } finally {
3718  95371 if (jjtc000) {
3719  16923 jjtree.closeNodeScope(jjtn000, true);
3720    }
3721    }
3722    }
3723   
 
3724  11460 toggle final public void BooleanLiteral() throws ParseException {
3725    /*@bgen(jjtree) BooleanLiteral */
3726  11460 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
3727  11460 boolean jjtc000 = true;
3728  11460 jjtree.openNodeScope(jjtn000);
3729  11460 try {
3730  11460 switch (jj_nt.kind) {
3731  7473 case TRUE:
3732  7473 jj_consume_token(TRUE);
3733  7473 jjtree.closeNodeScope(jjtn000, true);
3734  7473 jjtc000 = false;
3735  7473 jjtn000.setTrue();
3736  7473 break;
3737  3987 case FALSE:
3738  3987 jj_consume_token(FALSE);
3739  3987 break;
3740  0 default:
3741  0 jj_la1[96] = jj_gen;
3742  0 jj_consume_token(-1);
3743  0 throw new ParseException();
3744    }
3745    } finally {
3746  11460 if (jjtc000) {
3747  3987 jjtree.closeNodeScope(jjtn000, true);
3748    }
3749    }
3750    }
3751   
 
3752  5463 toggle final public void NullLiteral() throws ParseException {
3753    /*@bgen(jjtree) NullLiteral */
3754  5463 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
3755  5463 boolean jjtc000 = true;
3756  5463 jjtree.openNodeScope(jjtn000);
3757  5463 try {
3758  5463 jj_consume_token(NULL);
3759    } finally {
3760  5463 if (jjtc000) {
3761  5463 jjtree.closeNodeScope(jjtn000, true);
3762    }
3763    }
3764    }
3765   
 
3766  100241 toggle final public void Arguments() throws ParseException {
3767    /*@bgen(jjtree) Arguments */
3768  100262 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
3769  100278 boolean jjtc000 = true;
3770  100281 jjtree.openNodeScope(jjtn000);
3771  100288 try {
3772  100289 jj_consume_token(LPAREN);
3773  100274 switch (jj_nt.kind) {
3774  0 case BOOLEAN:
3775  3 case BYTE:
3776  0 case CHAR:
3777  0 case DOUBLE:
3778  201 case FALSE:
3779  3 case FLOAT:
3780  6 case INT:
3781  3 case LONG:
3782  1590 case NEW:
3783  171 case NULL:
3784  0 case SHORT:
3785  21 case SUPER:
3786  1443 case THIS:
3787  378 case TRUE:
3788  6 case VOID:
3789  7641 case INTEGER_LITERAL:
3790  51 case FLOATING_POINT_LITERAL:
3791  0 case HEX_FLOATING_POINT_LITERAL:
3792  669 case CHARACTER_LITERAL:
3793  11344 case STRING_LITERAL:
3794  36867 case IDENTIFIER:
3795  1662 case LPAREN:
3796  27 case BANG:
3797  0 case TILDE:
3798  6 case INCR:
3799  6 case DECR:
3800  0 case PLUS:
3801  264 case MINUS:
3802  62361 ArgumentList();
3803  62361 break;
3804  37903 default:
3805  37908 jj_la1[97] = jj_gen;
3806  37909 ;
3807    }
3808  100280 jj_consume_token(RPAREN);
3809    } catch (Throwable jjte000) {
3810  0 if (jjtc000) {
3811  0 jjtree.clearNodeScope(jjtn000);
3812  0 jjtc000 = false;
3813    } else {
3814  0 jjtree.popNode();
3815    }
3816  0 if (jjte000 instanceof RuntimeException) {
3817  0 {if (true) throw (RuntimeException)jjte000;}
3818    }
3819  0 if (jjte000 instanceof ParseException) {
3820  0 {if (true) throw (ParseException)jjte000;}
3821    }
3822  0 {if (true) throw (Error)jjte000;}
3823    } finally {
3824  100288 if (jjtc000) {
3825  100288 jjtree.closeNodeScope(jjtn000, true);
3826    }
3827    }
3828    }
3829   
 
3830  62353 toggle final public void ArgumentList() throws ParseException {
3831    /*@bgen(jjtree) ArgumentList */
3832  62372 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
3833  62358 boolean jjtc000 = true;
3834  62372 jjtree.openNodeScope(jjtn000);
3835  62374 try {
3836  62373 Expression();
3837  62340 label_39:
3838    while (true) {
3839  94884 switch (jj_nt.kind) {
3840  32519 case COMMA:
3841  32520 ;
3842  32514 break;
3843  62365 default:
3844  62360 jj_la1[98] = jj_gen;
3845  62364 break label_39;
3846    }
3847  32518 jj_consume_token(COMMA);
3848  32523 Expression();
3849    }
3850    } catch (Throwable jjte000) {
3851  0 if (jjtc000) {
3852  0 jjtree.clearNodeScope(jjtn000);
3853  0 jjtc000 = false;
3854    } else {
3855  0 jjtree.popNode();
3856    }
3857  0 if (jjte000 instanceof RuntimeException) {
3858  0 {if (true) throw (RuntimeException)jjte000;}
3859    }
3860  0 if (jjte000 instanceof ParseException) {
3861  0 {if (true) throw (ParseException)jjte000;}
3862    }
3863  0 {if (true) throw (Error)jjte000;}
3864    } finally {
3865  62372 if (jjtc000) {
3866  62371 jjtree.closeNodeScope(jjtn000, true);
3867    }
3868    }
3869    }
3870   
 
3871  13541 toggle final public void AllocationExpression() throws ParseException {
3872    /*@bgen(jjtree) AllocationExpression */
3873  13542 ASTAllocationExpression jjtn000 = new ASTAllocationExpression(this, JJTALLOCATIONEXPRESSION);
3874  13542 boolean jjtc000 = true;
3875  13542 jjtree.openNodeScope(jjtn000);
3876  13542 try {
3877  13542 if (jj_2_35(2)) {
3878  228 jj_consume_token(NEW);
3879  228 PrimitiveType();
3880  228 ArrayDimsAndInits();
3881    } else {
3882  13314 switch (jj_nt.kind) {
3883  13314 case NEW:
3884  13314 jj_consume_token(NEW);
3885  13314 ClassOrInterfaceType();
3886  13313 switch (jj_nt.kind) {
3887  0 case LT:
3888  0 TypeArguments();
3889  0 break;
3890  13313 default:
3891  13314 jj_la1[99] = jj_gen;
3892  13314 ;
3893    }
3894  13314 switch (jj_nt.kind) {
3895  900 case LBRACKET:
3896  900 ArrayDimsAndInits();
3897  900 break;
3898  12414 case LPAREN:
3899  12414 Arguments();
3900  12413 switch (jj_nt.kind) {
3901  423 case LBRACE:
3902  423 ClassOrInterfaceBody();
3903  423 break;
3904  11991 default:
3905  11991 jj_la1[100] = jj_gen;
3906  11990 ;
3907    }
3908  12414 break;
3909  0 default:
3910  0 jj_la1[101] = jj_gen;
3911  0 jj_consume_token(-1);
3912  0 throw new ParseException();
3913    }
3914  13314 break;
3915  0 default:
3916  0 jj_la1[102] = jj_gen;
3917  0 jj_consume_token(-1);
3918  0 throw new ParseException();
3919    }
3920    }
3921    } catch (Throwable jjte000) {
3922  0 if (jjtc000) {
3923  0 jjtree.clearNodeScope(jjtn000);
3924  0 jjtc000 = false;
3925    } else {
3926  0 jjtree.popNode();
3927    }
3928  0 if (jjte000 instanceof RuntimeException) {
3929  0 {if (true) throw (RuntimeException)jjte000;}
3930    }
3931  0 if (jjte000 instanceof ParseException) {
3932  0 {if (true) throw (ParseException)jjte000;}
3933    }
3934  0 {if (true) throw (Error)jjte000;}
3935    } finally {
3936  13542 if (jjtc000) {
3937  13541 jjtree.closeNodeScope(jjtn000, true);
3938    }
3939    }
3940    }
3941   
3942    /*
3943    * The second LOOKAHEAD specification below is to parse to PrimarySuffix
3944    * if there is an expression between the "[...]".
3945    */
 
3946  1128 toggle final public void ArrayDimsAndInits() throws ParseException {
3947    /*@bgen(jjtree) ArrayDimsAndInits */
3948  1128 ASTArrayDimsAndInits jjtn000 = new ASTArrayDimsAndInits(this, JJTARRAYDIMSANDINITS);
3949  1128 boolean jjtc000 = true;
3950  1128 jjtree.openNodeScope(jjtn000);
3951  1128 try {
3952  1128 if (jj_2_38(2)) {
3953  444 label_40:
3954    while (true) {
3955  447 jj_consume_token(LBRACKET);
3956  447 Expression();
3957  447 jj_consume_token(RBRACKET);
3958  447 if (jj_2_36(2)) {
3959  3 ;
3960    } else {
3961  444 break label_40;
3962    }
3963    }
3964  444 label_41:
3965    while (true) {
3966  456 if (jj_2_37(2)) {
3967  12 ;
3968    } else {
3969  444 break label_41;
3970    }
3971  12 jj_consume_token(LBRACKET);
3972  12 jj_consume_token(RBRACKET);
3973    }
3974    } else {
3975  684 switch (jj_nt.kind) {
3976  684 case LBRACKET:
3977  684 label_42:
3978    while (true) {
3979  702 jj_consume_token(LBRACKET);
3980  702 jj_consume_token(RBRACKET);
3981  702 switch (jj_nt.kind) {
3982  18 case LBRACKET:
3983  18 ;
3984  18 break;
3985  684 default:
3986  684 jj_la1[103] = jj_gen;
3987  684 break label_42;
3988    }
3989    }
3990  684 ArrayInitializer();
3991  684 break;
3992  0 default:
3993  0 jj_la1[104] = jj_gen;
3994  0 jj_consume_token(-1);
3995  0 throw new ParseException();
3996    }
3997    }
3998    } catch (Throwable jjte000) {
3999  0 if (jjtc000) {
4000  0 jjtree.clearNodeScope(jjtn000);
4001  0 jjtc000 = false;
4002    } else {
4003  0 jjtree.popNode();
4004    }
4005  0 if (jjte000 instanceof RuntimeException) {
4006  0 {if (true) throw (RuntimeException)jjte000;}
4007    }
4008  0 if (jjte000 instanceof ParseException) {
4009  0 {if (true) throw (ParseException)jjte000;}
4010    }
4011  0 {if (true) throw (Error)jjte000;}
4012    } finally {
4013  1128 if (jjtc000) {
4014  1128 jjtree.closeNodeScope(jjtn000, true);
4015    }
4016    }
4017    }
4018   
4019    /*
4020    * Statement syntax follows.
4021    */
 
4022  127028 toggle final public void Statement() throws ParseException {
4023    /*@bgen(jjtree) Statement */
4024  127038 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
4025  127026 boolean jjtc000 = true;
4026  127041 jjtree.openNodeScope(jjtn000);
4027  127036 try {
4028  127034 if (isNextTokenAnAssert()) {
4029  0 AssertStatement();
4030  127036 } else if (jj_2_39(2)) {
4031  261 LabeledStatement();
4032    } else {
4033  126781 switch (jj_nt.kind) {
4034  21118 case LBRACE:
4035  21120 Block();
4036  21120 break;
4037  453 case SEMICOLON:
4038  453 EmptyStatement();
4039  453 break;
4040  0 case BOOLEAN:
4041  0 case BYTE:
4042  0 case CHAR:
4043  0 case DOUBLE:
4044  0 case FALSE:
4045  0 case FLOAT:
4046  0 case INT:
4047  0 case LONG:
4048  147 case NEW:
4049  3 case NULL:
4050  0 case SHORT:
4051  582 case SUPER:
4052  2394 case THIS:
4053  3 case TRUE:
4054  0 case VOID:
4055  0 case INTEGER_LITERAL:
4056  0 case FLOATING_POINT_LITERAL:
4057  0 case HEX_FLOATING_POINT_LITERAL:
4058  0 case CHARACTER_LITERAL:
4059  3 case STRING_LITERAL:
4060  44421 case IDENTIFIER:
4061  84 case LPAREN:
4062  93 case INCR:
4063  36 case DECR:
4064  47773 StatementExpression();
4065  47770 jj_consume_token(SEMICOLON);
4066  47773 break;
4067  1188 case SWITCH:
4068  1188 SwitchStatement();
4069  1188 break;
4070  19930 case IF:
4071  19931 IfStatement();
4072  19932 break;
4073  1035 case WHILE:
4074  1035 WhileStatement();
4075  1035 break;
4076  348 case DO:
4077  348 DoStatement();
4078  348 break;
4079  3423 case FOR:
4080  3423 ForStatement();
4081  3420 break;
4082  4548 case BREAK:
4083  4548 BreakStatement();
4084  4548 break;
4085  672 case CONTINUE:
4086  672 ContinueStatement();
4087  672 break;
4088  21708 case RETURN:
4089  21712 ReturnStatement();
4090  21709 break;
4091  2610 case THROW:
4092  2610 ThrowStatement();
4093  2610 break;
4094  48 case SYNCHRONIZED:
4095  48 SynchronizedStatement();
4096  48 break;
4097  1914 case TRY:
4098  1914 TryStatement();
4099  1914 break;
4100  0 default:
4101  0 jj_la1[105] = jj_gen;
4102  0 jj_consume_token(-1);
4103  0 throw new ParseException();
4104    }
4105    }
4106    } catch (Throwable jjte000) {
4107  6 if (jjtc000) {
4108  6 jjtree.clearNodeScope(jjtn000);
4109  6 jjtc000 = false;
4110    } else {
4111  0 jjtree.popNode();
4112    }
4113  6 if (jjte000 instanceof RuntimeException) {
4114  6 {if (true) throw (RuntimeException)jjte000;}
4115    }
4116  0 if (jjte000 instanceof ParseException) {
4117  0 {if (true) throw (ParseException)jjte000;}
4118    }
4119  0 {if (true) throw (Error)jjte000;}
4120    } finally {
4121  127039 if (jjtc000) {
4122  127032 jjtree.closeNodeScope(jjtn000, true);
4123    }
4124    }
4125    }
4126   
 
4127  261 toggle final public void LabeledStatement() throws ParseException {
4128    /*@bgen(jjtree) LabeledStatement */
4129  261 ASTLabeledStatement jjtn000 = new ASTLabeledStatement(this, JJTLABELEDSTATEMENT);
4130  261 boolean jjtc000 = true;
4131  261 jjtree.openNodeScope(jjtn000);Token t;
4132  261 try {
4133  261 t = jj_consume_token(IDENTIFIER);
4134  261 jjtn000.setImage(t.image);
4135  261 jj_consume_token(COLON);
4136  261 Statement();
4137    } catch (Throwable jjte000) {
4138  0 if (jjtc000) {
4139  0 jjtree.clearNodeScope(jjtn000);
4140  0 jjtc000 = false;
4141    } else {
4142  0 jjtree.popNode();
4143    }
4144  0 if (jjte000 instanceof RuntimeException) {
4145  0 {if (true) throw (RuntimeException)jjte000;}
4146    }
4147  0 if (jjte000 instanceof ParseException) {
4148  0 {if (true) throw (ParseException)jjte000;}
4149    }
4150  0 {if (true) throw (Error)jjte000;}
4151    } finally {
4152  261 if (jjtc000) {
4153  261 jjtree.closeNodeScope(jjtn000, true);
4154    }
4155    }
4156    }
4157   
 
4158  51222 toggle final public void Block() throws ParseException {
4159    /*@bgen(jjtree) Block */
4160  51227 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
4161  51224 boolean jjtc000 = true;
4162  51226 jjtree.openNodeScope(jjtn000);Token t;
4163  51226 try {
4164  51223 jj_consume_token(LBRACE);
4165  51227 label_43:
4166    while (true) {
4167  153614 if (jj_2_40(1)) {
4168  102405 ;
4169    } else {
4170  51216 break label_43;
4171    }
4172  102401 BlockStatement();
4173    }
4174  51210 t = jj_consume_token(RBRACE);
4175  51222 jjtree.closeNodeScope(jjtn000, true);
4176  51221 jjtc000 = false;
4177  51222 if (isPrecededByComment(t)) { jjtn000.setContainsComment(); }
4178    } catch (Throwable jjte000) {
4179  6 if (jjtc000) {
4180  6 jjtree.clearNodeScope(jjtn000);
4181  6 jjtc000 = false;
4182    } else {
4183  0 jjtree.popNode();
4184    }
4185  6 if (jjte000 instanceof RuntimeException) {
4186  6 {if (true) throw (RuntimeException)jjte000;}
4187    }
4188  0 if (jjte000 instanceof ParseException) {
4189  0 {if (true) throw (ParseException)jjte000;}
4190    }
4191  0 {if (true) throw (Error)jjte000;}
4192    } finally {
4193  51226 if (jjtc000) {
4194  0 jjtree.closeNodeScope(jjtn000, true);
4195    }
4196    }
4197    }
4198   
 
4199  117486 toggle final public void BlockStatement() throws ParseException {
4200    /*@bgen(jjtree) BlockStatement */
4201  117501 ASTBlockStatement jjtn000 = new ASTBlockStatement(this, JJTBLOCKSTATEMENT);
4202  117500 boolean jjtc000 = true;
4203  117494 jjtree.openNodeScope(jjtn000);
4204  117504 try {
4205  117498 if (isNextTokenAnAssert()) {
4206  18 AssertStatement();
4207  117486 } else if (jj_2_41(2147483647)) {
4208  18693 LocalVariableDeclaration();
4209  18692 jj_consume_token(SEMICOLON);
4210  98800 } else if (jj_2_42(1)) {
4211  98779 Statement();
4212  21 } else if (jj_2_43(2147483647)) {
4213  21 switch (jj_nt.kind) {
4214  0 case AT:
4215  0 Annotation();
4216  0 break;
4217  21 default:
4218  21 jj_la1[106] = jj_gen;
4219  21 ;
4220    }
4221  21 ClassOrInterfaceDeclaration(0);
4222    } else {
4223  0 jj_consume_token(-1);
4224  0 throw new ParseException();
4225    }
4226    } catch (Throwable jjte000) {
4227  6 if (jjtc000) {
4228  6 jjtree.clearNodeScope(jjtn000);
4229  6 jjtc000 = false;
4230    } else {
4231  0 jjtree.popNode();
4232    }
4233  6 if (jjte000 instanceof RuntimeException) {
4234  6 {if (true) throw (RuntimeException)jjte000;}
4235    }
4236  0 if (jjte000 instanceof ParseException) {
4237  0 {if (true) throw (ParseException)jjte000;}
4238    }
4239  0 {if (true) throw (Error)jjte000;}
4240    } finally {
4241  117512 if (jjtc000) {
4242  117502 jjtree.closeNodeScope(jjtn000, true);
4243    }
4244    }
4245    }
4246   
 
4247  20328 toggle final public void LocalVariableDeclaration() throws ParseException {
4248    /*@bgen(jjtree) LocalVariableDeclaration */
4249  20328 ASTLocalVariableDeclaration jjtn000 = new ASTLocalVariableDeclaration(this, JJTLOCALVARIABLEDECLARATION);
4250  20328 boolean jjtc000 = true;
4251  20325 jjtree.openNodeScope(jjtn000);
4252  20328 try {
4253  20328 label_44:
4254    while (true) {
4255  20952 switch (jj_nt.kind) {
4256  606 case FINAL:
4257  18 case AT:
4258  624 ;
4259  624 break;
4260  20326 default:
4261  20328 jj_la1[107] = jj_gen;
4262  20328 break label_44;
4263    }
4264  624 switch (jj_nt.kind) {
4265  606 case FINAL:
4266  606 jj_consume_token(FINAL);
4267  606 jjtn000.setFinal(true);
4268  606 break;
4269  18 case AT:
4270  18 Annotation();
4271  18 break;
4272  0 default:
4273  0 jj_la1[108] = jj_gen;
4274  0 jj_consume_token(-1);
4275  0 throw new ParseException();
4276    }
4277    }
4278  20325 Type();
4279  20328 VariableDeclarator();
4280  20324 label_45:
4281    while (true) {
4282  20360 switch (jj_nt.kind) {
4283  33 case COMMA:
4284  33 ;
4285  33 break;
4286  20326 default:
4287  20325 jj_la1[109] = jj_gen;
4288  20326 break label_45;
4289    }
4290  33 jj_consume_token(COMMA);
4291  33 VariableDeclarator();
4292    }
4293    } catch (Throwable jjte000) {
4294  0 if (jjtc000) {
4295  0 jjtree.clearNodeScope(jjtn000);
4296  0 jjtc000 = false;
4297    } else {
4298  0 jjtree.popNode();
4299    }
4300  0 if (jjte000 instanceof RuntimeException) {
4301  0 {if (true) throw (RuntimeException)jjte000;}
4302    }
4303  0 if (jjte000 instanceof ParseException) {
4304  0 {if (true) throw (ParseException)jjte000;}
4305    }
4306  0 {if (true) throw (Error)jjte000;}
4307    } finally {
4308  20326 if (jjtc000) {
4309  20325 jjtree.closeNodeScope(jjtn000, true);
4310    }
4311    }
4312    }
4313   
 
4314  453 toggle final public void EmptyStatement() throws ParseException {
4315    /*@bgen(jjtree) EmptyStatement */
4316  453 ASTEmptyStatement jjtn000 = new ASTEmptyStatement(this, JJTEMPTYSTATEMENT);
4317  453 boolean jjtc000 = true;
4318  453 jjtree.openNodeScope(jjtn000);
4319  453 try {
4320  453 jj_consume_token(SEMICOLON);
4321    } finally {
4322  453 if (jjtc000) {
4323  453 jjtree.closeNodeScope(jjtn000, true);
4324    }
4325    }
4326    }
4327   
 
4328  49129 toggle final public void StatementExpression() throws ParseException {
4329    /*@bgen(jjtree) StatementExpression */
4330  49139 ASTStatementExpression jjtn000 = new ASTStatementExpression(this, JJTSTATEMENTEXPRESSION);
4331  49138 boolean jjtc000 = true;
4332  49141 jjtree.openNodeScope(jjtn000);
4333  49142 try {
4334  49140 switch (jj_nt.kind) {
4335  105 case INCR:
4336  105 PreIncrementExpression();
4337  105 break;
4338  36 case DECR:
4339  36 PreDecrementExpression();
4340  36 break;
4341  48999 default:
4342  49000 jj_la1[111] = jj_gen;
4343  48986 if (jj_2_44(2147483647)) {
4344  1866 PostfixExpression();
4345    } else {
4346  47127 switch (jj_nt.kind) {
4347  0 case BOOLEAN:
4348  0 case BYTE:
4349  0 case CHAR:
4350  0 case DOUBLE:
4351  0 case FALSE:
4352  0 case FLOAT:
4353  0 case INT:
4354  0 case LONG:
4355  147 case NEW:
4356  3 case NULL:
4357  0 case SHORT:
4358  579 case SUPER:
4359  2391 case THIS:
4360  3 case TRUE:
4361  0 case VOID:
4362  0 case INTEGER_LITERAL:
4363  0 case FLOATING_POINT_LITERAL:
4364  0 case HEX_FLOATING_POINT_LITERAL:
4365  0 case CHARACTER_LITERAL:
4366  3 case STRING_LITERAL:
4367  43920 case IDENTIFIER:
4368  81 case LPAREN:
4369  47129 PrimaryExpression();
4370  47127 switch (jj_nt.kind) {
4371  14502 case ASSIGN:
4372  396 case PLUSASSIGN:
4373  27 case MINUSASSIGN:
4374  30 case STARASSIGN:
4375  18 case SLASHASSIGN:
4376  24 case ANDASSIGN:
4377  54 case ORASSIGN:
4378  21 case XORASSIGN:
4379  18 case REMASSIGN:
4380  18 case LSHIFTASSIGN:
4381  18 case RSIGNEDSHIFTASSIGN:
4382  18 case RUNSIGNEDSHIFTASSIGN:
4383  15144 AssignmentOperator();
4384  15144 Expression();
4385  15143 break;
4386  31984 default:
4387  31990 jj_la1[110] = jj_gen;
4388  31990 ;
4389    }
4390  47135 break;
4391  0 default:
4392  0 jj_la1[112] = jj_gen;
4393  0 jj_consume_token(-1);
4394  0 throw new ParseException();
4395    }
4396    }
4397    }
4398    } catch (Throwable jjte000) {
4399  0 if (jjtc000) {
4400  0 jjtree.clearNodeScope(jjtn000);
4401  0 jjtc000 = false;
4402    } else {
4403  0 jjtree.popNode();
4404    }
4405  0 if (jjte000 instanceof RuntimeException) {
4406  0 {if (true) throw (RuntimeException)jjte000;}
4407    }
4408  0 if (jjte000 instanceof ParseException) {
4409  0 {if (true) throw (ParseException)jjte000;}
4410    }
4411  0 {if (true) throw (Error)jjte000;}
4412    } finally {
4413  49140 if (jjtc000) {
4414  49140 jjtree.closeNodeScope(jjtn000, true);
4415    }
4416    }
4417    }
4418   
 
4419  1188 toggle final public void SwitchStatement() throws ParseException {
4420    /*@bgen(jjtree) SwitchStatement */
4421  1188 ASTSwitchStatement jjtn000 = new ASTSwitchStatement(this, JJTSWITCHSTATEMENT);
4422  1188 boolean jjtc000 = true;
4423  1188 jjtree.openNodeScope(jjtn000);
4424  1188 try {
4425  1188 jj_consume_token(SWITCH);
4426  1188 jj_consume_token(LPAREN);
4427  1188 Expression();
4428  1188 jj_consume_token(RPAREN);
4429  1188 jj_consume_token(LBRACE);
4430  1188 label_46:
4431    while (true) {
4432  9405 switch (jj_nt.kind) {
4433  7089 case CASE:
4434  1131 case _DEFAULT:
4435  8220 ;
4436  8220 break;
4437  1188 default:
4438  1188 jj_la1[113] = jj_gen;
4439  1188 break label_46;
4440    }
4441  8220 SwitchLabel();
4442  8219 label_47:
4443    while (true) {
4444  19991 if (jj_2_45(1)) {
4445  11775 ;
4446    } else {
4447  8220 break label_47;
4448    }
4449  11775 BlockStatement();
4450    }
4451    }
4452  1188 jj_consume_token(RBRACE);
4453    } catch (Throwable jjte000) {
4454  0 if (jjtc000) {
4455  0 jjtree.clearNodeScope(jjtn000);
4456  0 jjtc000 = false;
4457    } else {
4458  0 jjtree.popNode();
4459    }
4460  0 if (jjte000 instanceof RuntimeException) {
4461  0 {if (true) throw (RuntimeException)jjte000;}
4462    }
4463  0 if (jjte000 instanceof ParseException) {
4464  0 {if (true) throw (ParseException)jjte000;}
4465    }
4466  0 {if (true) throw (Error)jjte000;}
4467    } finally {
4468  1188 if (jjtc000) {
4469  1188 jjtree.closeNodeScope(jjtn000, true);
4470    }
4471    }
4472    }
4473   
 
4474  8216 toggle final public void SwitchLabel() throws ParseException {
4475    /*@bgen(jjtree) SwitchLabel */
4476  8220 ASTSwitchLabel jjtn000 = new ASTSwitchLabel(this, JJTSWITCHLABEL);
4477  8219 boolean jjtc000 = true;
4478  8219 jjtree.openNodeScope(jjtn000);
4479  8220 try {
4480  8220 switch (jj_nt.kind) {
4481  7089 case CASE:
4482  7089 jj_consume_token(CASE);
4483  7089 Expression();
4484  7084 jj_consume_token(COLON);
4485  7089 break;
4486  1131 case _DEFAULT:
4487  1131 jj_consume_token(_DEFAULT);
4488  1131 jjtn000.setDefault();
4489  1131 jj_consume_token(COLON);
4490  1131 break;
4491  0 default:
4492  0 jj_la1[114] = jj_gen;
4493  0 jj_consume_token(-1);
4494  0 throw new ParseException();
4495    }
4496    } catch (Throwable jjte000) {
4497  0 if (jjtc000) {
4498  0 jjtree.clearNodeScope(jjtn000);
4499  0 jjtc000 = false;
4500    } else {
4501  0 jjtree.popNode();
4502    }
4503  0 if (jjte000 instanceof RuntimeException) {
4504  0 {if (true) throw (RuntimeException)jjte000;}
4505    }
4506  0 if (jjte000 instanceof ParseException) {
4507  0 {if (true) throw (ParseException)jjte000;}
4508    }
4509  0 {if (true) throw (Error)jjte000;}
4510    } finally {
4511  8220 if (jjtc000) {
4512  8220 jjtree.closeNodeScope(jjtn000, true);
4513    }
4514    }
4515    }
4516   
 
4517  19931 toggle final public void IfStatement() throws ParseException {
4518    /*@bgen(jjtree) IfStatement */
4519  19932 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
4520  19932 boolean jjtc000 = true;
4521  19932 jjtree.openNodeScope(jjtn000);
4522  19931 try {
4523  19932 jj_consume_token(IF);
4524  19930 jj_consume_token(LPAREN);
4525  19932 Expression();
4526  19928 jj_consume_token(RPAREN);
4527  19931 Statement();
4528  19932 switch (jj_nt.kind) {
4529  3267 case ELSE:
4530  3267 jj_consume_token(ELSE);
4531  3267 jjtn000.setHasElse();
4532  3267 Statement();
4533  3267 break;
4534  16665 default:
4535  16665 jj_la1[115] = jj_gen;
4536  16665 ;
4537    }
4538  19932 jjtree.closeNodeScope(jjtn000, true);
4539  19932 jjtc000 = false;
4540   
4541    } catch (Throwable jjte000) {
4542  0 if (jjtc000) {
4543  0 jjtree.clearNodeScope(jjtn000);
4544  0 jjtc000 = false;
4545    } else {
4546  0 jjtree.popNode();
4547    }
4548  0 if (jjte000 instanceof RuntimeException) {
4549  0 {if (true) throw (RuntimeException)jjte000;}
4550    }
4551  0 if (jjte000 instanceof ParseException) {
4552  0 {if (true) throw (ParseException)jjte000;}
4553    }
4554  0 {if (true) throw (Error)jjte000;}
4555    } finally {
4556  19932 if (jjtc000) {
4557  0 jjtree.closeNodeScope(jjtn000, true);
4558    }
4559    }
4560    }
4561   
 
4562  1035 toggle final public void WhileStatement() throws ParseException {
4563    /*@bgen(jjtree) WhileStatement */
4564  1035 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
4565  1035 boolean jjtc000 = true;
4566  1035 jjtree.openNodeScope(jjtn000);
4567  1035 try {
4568  1035 jj_consume_token(WHILE);
4569  1035 jj_consume_token(LPAREN);
4570  1035 Expression();
4571  1035 jj_consume_token(RPAREN);
4572  1035 Statement();
4573    } catch (Throwable jjte000) {
4574  0 if (jjtc000) {
4575  0 jjtree.clearNodeScope(jjtn000);
4576  0 jjtc000 = false;
4577    } else {
4578  0 jjtree.popNode();
4579    }
4580  0 if (jjte000 instanceof RuntimeException) {
4581  0 {if (true) throw (RuntimeException)jjte000;}
4582    }
4583  0 if (jjte000 instanceof ParseException) {
4584  0 {if (true) throw (ParseException)jjte000;}
4585    }
4586  0 {if (true) throw (Error)jjte000;}
4587    } finally {
4588  1035 if (jjtc000) {
4589  1035 jjtree.closeNodeScope(jjtn000, true);
4590    }
4591    }
4592    }
4593   
 
4594  348 toggle final public void DoStatement() throws ParseException {
4595    /*@bgen(jjtree) DoStatement */
4596  348 ASTDoStatement jjtn000 = new ASTDoStatement(this, JJTDOSTATEMENT);
4597  348 boolean jjtc000 = true;
4598  348 jjtree.openNodeScope(jjtn000);
4599  348 try {
4600  348 jj_consume_token(DO);
4601  348 Statement();
4602  348 jj_consume_token(WHILE);
4603  348 jj_consume_token(LPAREN);
4604  348 Expression();
4605  348 jj_consume_token(RPAREN);
4606  348 jj_consume_token(SEMICOLON);
4607    } catch (Throwable jjte000) {
4608  0 if (jjtc000) {
4609  0 jjtree.clearNodeScope(jjtn000);
4610  0 jjtc000 = false;
4611    } else {
4612  0 jjtree.popNode();
4613    }
4614  0 if (jjte000 instanceof RuntimeException) {
4615  0 {if (true) throw (RuntimeException)jjte000;}
4616    }
4617  0 if (jjte000 instanceof ParseException) {
4618  0 {if (true) throw (ParseException)jjte000;}
4619    }
4620  0 {if (true) throw (Error)jjte000;}
4621    } finally {
4622  348 if (jjtc000) {
4623  348 jjtree.closeNodeScope(jjtn000, true);
4624    }
4625    }
4626    }
4627   
 
4628  3423 toggle final public void ForStatement() throws ParseException {
4629    /*@bgen(jjtree) ForStatement */
4630  3423 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
4631  3423 boolean jjtc000 = true;
4632  3423 jjtree.openNodeScope(jjtn000);
4633  3423 try {
4634  3423 jj_consume_token(FOR);
4635  3423 jj_consume_token(LPAREN);
4636  3423 if (jj_2_46(2147483647)) {
4637  1629 checkForBadJDK15ForLoopSyntaxArgumentsUsage();
4638  1626 Modifiers();
4639  1626 Type();
4640  1626 jj_consume_token(IDENTIFIER);
4641  1626 jj_consume_token(COLON);
4642  1626 Expression();
4643    } else {
4644  1794 switch (jj_nt.kind) {
4645  0 case BOOLEAN:
4646  0 case BYTE:
4647  0 case CHAR:
4648  3 case DOUBLE:
4649  0 case FALSE:
4650  0 case FINAL:
4651  3 case FLOAT:
4652  1425 case INT:
4653  0 case LONG:
4654  0 case NEW:
4655  0 case NULL:
4656  0 case SHORT:
4657  0 case SUPER:
4658  0 case THIS:
4659  0 case TRUE:
4660  0 case VOID:
4661  0 case INTEGER_LITERAL:
4662  0 case FLOATING_POINT_LITERAL:
4663  0 case HEX_FLOATING_POINT_LITERAL:
4664  0 case CHARACTER_LITERAL:
4665  0 case STRING_LITERAL:
4666  234 case IDENTIFIER:
4667  0 case LPAREN:
4668  129 case SEMICOLON:
4669  0 case AT:
4670  0 case INCR:
4671  0 case DECR:
4672  1794 switch (jj_nt.kind) {
4673  0 case BOOLEAN:
4674  0 case BYTE:
4675  0 case CHAR:
4676  3 case DOUBLE:
4677  0 case FALSE:
4678  0 case FINAL:
4679  3 case FLOAT:
4680  1425 case INT:
4681  0 case LONG:
4682  0 case NEW:
4683  0 case NULL:
4684  0 case SHORT:
4685  0 case SUPER:
4686  0 case THIS:
4687  0 case TRUE:
4688  0 case VOID:
4689  0 case INTEGER_LITERAL:
4690  0 case FLOATING_POINT_LITERAL:
4691  0 case HEX_FLOATING_POINT_LITERAL:
4692  0 case CHARACTER_LITERAL:
4693  0 case STRING_LITERAL:
4694  234 case IDENTIFIER:
4695  0 case LPAREN:
4696  0 case AT:
4697  0 case INCR:
4698  0 case DECR:
4699  1665 ForInit();
4700  1665 break;
4701  129 default:
4702  129 jj_la1[116] = jj_gen;
4703  129 ;
4704    }
4705  1794 jj_consume_token(SEMICOLON);
4706  1794 switch (jj_nt.kind) {
4707  0 case BOOLEAN:
4708  0 case BYTE:
4709  0 case CHAR:
4710  0 case DOUBLE:
4711  0 case FALSE:
4712  0 case FLOAT:
4713  0 case INT:
4714  0 case LONG:
4715  0 case NEW:
4716  0 case NULL:
4717  0 case SHORT:
4718  0 case SUPER:
4719  0 case THIS:
4720  0 case TRUE:
4721  0 case VOID:
4722  0 case INTEGER_LITERAL:
4723  0 case FLOATING_POINT_LITERAL:
4724  0 case HEX_FLOATING_POINT_LITERAL:
4725  0 case CHARACTER_LITERAL:
4726  0 case STRING_LITERAL:
4727  1668 case IDENTIFIER:
4728  6 case LPAREN:
4729  6 case BANG:
4730  0 case TILDE:
4731  0 case INCR:
4732  0 case DECR:
4733  0 case PLUS:
4734  0 case MINUS:
4735  1680 Expression();
4736  1680 break;
4737  114 default:
4738  114 jj_la1[117] = jj_gen;
4739  114 ;
4740    }
4741  1794 jj_consume_token(SEMICOLON);
4742  1794 switch (jj_nt.kind) {
4743  0 case BOOLEAN:
4744  0 case BYTE:
4745  0 case CHAR:
4746  0 case DOUBLE:
4747  0 case FALSE:
4748  0 case FLOAT:
4749  0 case INT:
4750  0 case LONG:
4751  0 case NEW:
4752  0 case NULL:
4753  0 case SHORT:
4754  0 case SUPER:
4755  0 case THIS:
4756  0 case TRUE:
4757  0 case VOID:
4758  0 case INTEGER_LITERAL:
4759  0 case FLOATING_POINT_LITERAL:
4760  0 case HEX_FLOATING_POINT_LITERAL:
4761  0 case CHARACTER_LITERAL:
4762  0 case STRING_LITERAL:
4763  1320 case IDENTIFIER:
4764  0 case LPAREN:
4765  12 case INCR:
4766  0 case DECR:
4767  1332 ForUpdate();
4768  1332 break;
4769  462 default:
4770  462 jj_la1[118] = jj_gen;
4771  462 ;
4772    }
4773  1794 break;
4774  0 default:
4775  0 jj_la1[119] = jj_gen;
4776  0 jj_consume_token(-1);
4777  0 throw new ParseException();
4778    }
4779    }
4780  3420 jj_consume_token(RPAREN);
4781  3420 Statement();
4782    } catch (Throwable jjte000) {
4783  3 if (jjtc000) {
4784  3 jjtree.clearNodeScope(jjtn000);
4785  3 jjtc000 = false;
4786    } else {
4787  0 jjtree.popNode();
4788    }
4789  3 if (jjte000 instanceof RuntimeException) {
4790  3 {if (true) throw (RuntimeException)jjte000;}
4791    }
4792  0 if (jjte000 instanceof ParseException) {
4793  0 {if (true) throw (ParseException)jjte000;}
4794    }
4795  0 {if (true) throw (Error)jjte000;}
4796    } finally {
4797  3423 if (jjtc000) {
4798  3420 jjtree.closeNodeScope(jjtn000, true);
4799    }
4800    }
4801    }
4802   
 
4803  1665 toggle final public void ForInit() throws ParseException {
4804    /*@bgen(jjtree) ForInit */
4805  1665 ASTForInit jjtn000 = new ASTForInit(this, JJTFORINIT);
4806  1665 boolean jjtc000 = true;
4807  1665 jjtree.openNodeScope(jjtn000);
4808  1665 try {
4809  1665 if (jj_2_47(2147483647)) {
4810  1635 LocalVariableDeclaration();
4811    } else {
4812  30 switch (jj_nt.kind) {
4813  0 case BOOLEAN:
4814  0 case BYTE:
4815  0 case CHAR:
4816  0 case DOUBLE:
4817  0 case FALSE:
4818  0 case FLOAT:
4819  0 case INT:
4820  0 case LONG:
4821  0 case NEW:
4822  0 case NULL:
4823  0 case SHORT:
4824  0 case SUPER:
4825  0 case THIS:
4826  0 case TRUE:
4827  0 case VOID:
4828  0 case INTEGER_LITERAL:
4829  0 case FLOATING_POINT_LITERAL:
4830  0 case HEX_FLOATING_POINT_LITERAL:
4831  0 case CHARACTER_LITERAL:
4832  0 case STRING_LITERAL:
4833  30 case IDENTIFIER:
4834  0 case LPAREN:
4835  0 case INCR:
4836  0 case DECR:
4837  30 StatementExpressionList();
4838  30 break;
4839  0 default:
4840  0 jj_la1[120] = jj_gen;
4841  0 jj_consume_token(-1);
4842  0 throw new ParseException();
4843    }
4844    }
4845    } catch (Throwable jjte000) {
4846  0 if (jjtc000) {
4847  0 jjtree.clearNodeScope(jjtn000);
4848  0 jjtc000 = false;
4849    } else {
4850  0 jjtree.popNode();
4851    }
4852  0 if (jjte000 instanceof RuntimeException) {
4853  0 {if (true) throw (RuntimeException)jjte000;}
4854    }
4855  0 if (jjte000 instanceof ParseException) {
4856  0 {if (true) throw (ParseException)jjte000;}
4857    }
4858  0 {if (true) throw (Error)jjte000;}
4859    } finally {
4860  1665 if (jjtc000) {
4861  1665 jjtree.closeNodeScope(jjtn000, true);
4862    }
4863    }
4864    }
4865   
 
4866  1362 toggle final public void StatementExpressionList() throws ParseException {
4867    /*@bgen(jjtree) StatementExpressionList */
4868  1362 ASTStatementExpressionList jjtn000 = new ASTStatementExpressionList(this, JJTSTATEMENTEXPRESSIONLIST);
4869  1362 boolean jjtc000 = true;
4870  1362 jjtree.openNodeScope(jjtn000);
4871  1362 try {
4872  1362 StatementExpression();
4873  1362 label_48:
4874    while (true) {
4875  1365 switch (jj_nt.kind) {
4876  3 case COMMA:
4877  3 ;
4878  3 break;
4879  1362 default:
4880  1362 jj_la1[121] = jj_gen;
4881  1362 break label_48;
4882    }
4883  3 jj_consume_token(COMMA);
4884  3 StatementExpression();
4885    }
4886    } catch (Throwable jjte000) {
4887  0 if (jjtc000) {
4888  0 jjtree.clearNodeScope(jjtn000);
4889  0 jjtc000 = false;
4890    } else {
4891  0 jjtree.popNode();
4892    }
4893  0 if (jjte000 instanceof RuntimeException) {
4894  0 {if (true) throw (RuntimeException)jjte000;}
4895    }
4896  0 if (jjte000 instanceof ParseException) {
4897  0 {if (true) throw (ParseException)jjte000;}
4898    }
4899  0 {if (true) throw (Error)jjte000;}
4900    } finally {
4901  1362 if (jjtc000) {
4902  1362 jjtree.closeNodeScope(jjtn000, true);
4903    }
4904    }
4905    }
4906   
 
4907  1332 toggle final public void ForUpdate() throws ParseException {
4908    /*@bgen(jjtree) ForUpdate */
4909  1332 ASTForUpdate jjtn000 = new ASTForUpdate(this, JJTFORUPDATE);
4910  1332 boolean jjtc000 = true;
4911  1332 jjtree.openNodeScope(jjtn000);
4912  1332 try {
4913  1332 StatementExpressionList();
4914    } catch (Throwable jjte000) {
4915  0 if (jjtc000) {
4916  0 jjtree.clearNodeScope(jjtn000);
4917  0 jjtc000 = false;
4918    } else {
4919  0 jjtree.popNode();
4920    }
4921  0 if (jjte000 instanceof RuntimeException) {
4922  0 {if (true) throw (RuntimeException)jjte000;}
4923    }
4924  0 if (jjte000 instanceof ParseException) {
4925  0 {if (true) throw (ParseException)jjte000;}
4926    }
4927  0 {if (true) throw (Error)jjte000;}
4928    } finally {
4929  1332 if (jjtc000) {
4930  1332 jjtree.closeNodeScope(jjtn000, true);
4931    }
4932    }
4933    }
4934   
 
4935  4548 toggle final public void BreakStatement() throws ParseException {
4936    /*@bgen(jjtree) BreakStatement */
4937  4548 ASTBreakStatement jjtn000 = new ASTBreakStatement(this, JJTBREAKSTATEMENT);
4938  4548 boolean jjtc000 = true;
4939  4548 jjtree.openNodeScope(jjtn000);Token t;
4940  4548 try {
4941  4548 jj_consume_token(BREAK);
4942  4548 switch (jj_nt.kind) {
4943  207 case IDENTIFIER:
4944  207 t = jj_consume_token(IDENTIFIER);
4945  207 jjtn000.setImage(t.image);
4946  207 break;
4947  4341 default:
4948  4341 jj_la1[122] = jj_gen;
4949  4341 ;
4950    }
4951  4548 jj_consume_token(SEMICOLON);
4952    } finally {
4953  4548 if (jjtc000) {
4954  4548 jjtree.closeNodeScope(jjtn000, true);
4955    }
4956    }
4957    }
4958   
 
4959  672 toggle final public void ContinueStatement() throws ParseException {
4960    /*@bgen(jjtree) ContinueStatement */
4961  672 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
4962  672 boolean jjtc000 = true;
4963  672 jjtree.openNodeScope(jjtn000);Token t;
4964  672 try {
4965  672 jj_consume_token(CONTINUE);
4966  672 switch (jj_nt.kind) {
4967  18 case IDENTIFIER:
4968  18 t = jj_consume_token(IDENTIFIER);
4969  18 jjtn000.setImage(t.image);
4970  18 break;
4971  654 default:
4972  654 jj_la1[123] = jj_gen;
4973  654 ;
4974    }
4975  672 jj_consume_token(SEMICOLON);
4976    } finally {
4977  672 if (jjtc000) {
4978  672 jjtree.closeNodeScope(jjtn000, true);
4979    }
4980    }
4981    }
4982   
 
4983  21706 toggle final public void ReturnStatement() throws ParseException {
4984    /*@bgen(jjtree) ReturnStatement */
4985  21712 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
4986  21714 boolean jjtc000 = true;
4987  21713 jjtree.openNodeScope(jjtn000);
4988  21713 try {
4989  21713 jj_consume_token(RETURN);
4990  21712 switch (jj_nt.kind) {
4991  0 case BOOLEAN:
4992  0 case BYTE:
4993  0 case CHAR:
4994  0 case DOUBLE:
4995  2034 case FALSE:
4996  0 case FLOAT:
4997  0 case INT:
4998  0 case LONG:
4999  1230 case NEW:
5000  558 case NULL:
5001  0 case SHORT:
5002  924 case SUPER:
5003  351 case THIS:
5004  2865 case TRUE:
5005  3 case VOID:
5006  717 case INTEGER_LITERAL:
5007  0 case FLOATING_POINT_LITERAL:
5008  0 case HEX_FLOATING_POINT_LITERAL:
5009  21 case CHARACTER_LITERAL:
5010  489 case STRING_LITERAL:
5011  11137 case IDENTIFIER:
5012  753 case LPAREN:
5013  237 case BANG:
5014  0 case TILDE:
5015  3 case INCR:
5016  0 case DECR:
5017  0 case PLUS:
5018  162 case MINUS:
5019  21484 Expression();
5020  21481 break;
5021  228 default:
5022  228 jj_la1[124] = jj_gen;
5023  228 ;
5024    }
5025  21714 jj_consume_token(SEMICOLON);
5026    } catch (Throwable jjte000) {
5027  0 if (jjtc000) {
5028  0 jjtree.clearNodeScope(jjtn000);
5029  0 jjtc000 = false;
5030    } else {
5031  0 jjtree.popNode();
5032    }
5033  0 if (jjte000 instanceof RuntimeException) {
5034  0 {if (true) throw (RuntimeException)jjte000;}
5035    }
5036  0 if (jjte000 instanceof ParseException) {
5037  0 {if (true) throw (ParseException)jjte000;}
5038    }
5039  0 {if (true) throw (Error)jjte000;}
5040    } finally {
5041  21714 if (jjtc000) {
5042  21712 jjtree.closeNodeScope(jjtn000, true);
5043    }
5044    }
5045    }
5046   
 
5047  2610 toggle final public void ThrowStatement() throws ParseException {
5048    /*@bgen(jjtree) ThrowStatement */
5049  2610 ASTThrowStatement jjtn000 = new ASTThrowStatement(this, JJTTHROWSTATEMENT);
5050  2610 boolean jjtc000 = true;
5051  2610 jjtree.openNodeScope(jjtn000);
5052  2610 try {
5053  2610 jj_consume_token(THROW);
5054  2610 Expression();
5055  2610 jj_consume_token(SEMICOLON);
5056    } catch (Throwable jjte000) {
5057  0 if (jjtc000) {
5058  0 jjtree.clearNodeScope(jjtn000);
5059  0 jjtc000 = false;
5060    } else {
5061  0 jjtree.popNode();
5062    }
5063  0 if (jjte000 instanceof RuntimeException) {
5064  0 {if (true) throw (RuntimeException)jjte000;}
5065    }
5066  0 if (jjte000 instanceof ParseException) {
5067  0 {if (true) throw (ParseException)jjte000;}
5068    }
5069  0 {if (true) throw (Error)jjte000;}
5070    } finally {
5071  2610 if (jjtc000) {
5072  2610 jjtree.closeNodeScope(jjtn000, true);
5073    }
5074    }
5075    }
5076   
 
5077  48 toggle final public void SynchronizedStatement() throws ParseException {
5078    /*@bgen(jjtree) SynchronizedStatement */
5079  48 ASTSynchronizedStatement jjtn000 = new ASTSynchronizedStatement(this, JJTSYNCHRONIZEDSTATEMENT);
5080  48 boolean jjtc000 = true;
5081  48 jjtree.openNodeScope(jjtn000);
5082  48 try {
5083  48 jj_consume_token(SYNCHRONIZED);
5084  48 jj_consume_token(LPAREN);
5085  48 Expression();
5086  48 jj_consume_token(RPAREN);
5087  48 Block();
5088    } catch (Throwable jjte000) {
5089  0 if (jjtc000) {
5090  0 jjtree.clearNodeScope(jjtn000);
5091  0 jjtc000 = false;
5092    } else {
5093  0 jjtree.popNode();
5094    }
5095  0 if (jjte000 instanceof RuntimeException) {
5096  0 {if (true) throw (RuntimeException)jjte000;}
5097    }
5098  0 if (jjte000 instanceof ParseException) {
5099  0 {if (true) throw (ParseException)jjte000;}
5100    }
5101  0 {if (true) throw (Error)jjte000;}
5102    } finally {
5103  48 if (jjtc000) {
5104  48 jjtree.closeNodeScope(jjtn000, true);
5105    }
5106    }
5107    }
5108   
 
5109  1914 toggle final public void TryStatement() throws ParseException {
5110    /*@bgen(jjtree) TryStatement */
5111  1914 ASTTryStatement jjtn000 = new ASTTryStatement(this, JJTTRYSTATEMENT);
5112  1914 boolean jjtc000 = true;
5113  1914 jjtree.openNodeScope(jjtn000);
5114  1914 try {
5115  1914 jj_consume_token(TRY);
5116  1914 switch (jj_nt.kind) {
5117  12 case LPAREN:
5118  12 ResourceSpecification();
5119  12 break;
5120  1902 default:
5121  1902 jj_la1[125] = jj_gen;
5122  1902 ;
5123    }
5124  1914 Block();
5125  1914 label_49:
5126    while (true) {
5127  3792 switch (jj_nt.kind) {
5128  1878 case CATCH:
5129  1878 ;
5130  1878 break;
5131  1914 default:
5132  1914 jj_la1[126] = jj_gen;
5133  1914 break label_49;
5134    }
5135  1878 CatchStatement();
5136    }
5137  1914 switch (jj_nt.kind) {
5138  726 case FINALLY:
5139  726 FinallyStatement();
5140  726 break;
5141  1188 default:
5142  1188 jj_la1[127] = jj_gen;
5143  1188 ;
5144    }
5145    } catch (Throwable jjte000) {
5146  0 if (jjtc000) {
5147  0 jjtree.clearNodeScope(jjtn000);
5148  0 jjtc000 = false;
5149    } else {
5150  0 jjtree.popNode();
5151    }
5152  0 if (jjte000 instanceof RuntimeException) {
5153  0 {if (true) throw (RuntimeException)jjte000;}
5154    }
5155  0 if (jjte000 instanceof ParseException) {
5156  0 {if (true) throw (ParseException)jjte000;}
5157    }
5158  0 {if (true) throw (Error)jjte000;}
5159    } finally {
5160  1914 if (jjtc000) {
5161  1914 jjtree.closeNodeScope(jjtn000, true);
5162    }
5163    }
5164    }
5165   
 
5166  12 toggle final public void ResourceSpecification() throws ParseException {
5167    /*@bgen(jjtree) ResourceSpecification */
5168  12 ASTResourceSpecification jjtn000 = new ASTResourceSpecification(this, JJTRESOURCESPECIFICATION);
5169  12 boolean jjtc000 = true;
5170  12 jjtree.openNodeScope(jjtn000);
5171  12 try {
5172  12 checkForBadTryWithResourcesUsage();
5173  12 jj_consume_token(LPAREN);
5174  12 Resources();
5175  12 if (jj_2_48(2)) {
5176  3 jj_consume_token(SEMICOLON);
5177    } else {
5178  9 ;
5179    }
5180  12 jj_consume_token(RPAREN);
5181    } catch (Throwable jjte000) {
5182  0 if (jjtc000) {
5183  0 jjtree.clearNodeScope(jjtn000);
5184  0 jjtc000 = false;
5185    } else {
5186  0 jjtree.popNode();
5187    }
5188  0 if (jjte000 instanceof RuntimeException) {
5189  0 {if (true) throw (RuntimeException)jjte000;}
5190    }
5191  0 if (jjte000 instanceof ParseException) {
5192  0 {if (true) throw (ParseException)jjte000;}
5193    }
5194  0 {if (true) throw (Error)jjte000;}
5195    } finally {
5196  12 if (jjtc000) {
5197  12 jjtree.closeNodeScope(jjtn000, true);
5198    }
5199    }
5200    }
5201   
 
5202  12 toggle final public void Resources() throws ParseException {
5203    /*@bgen(jjtree) Resources */
5204  12 ASTResources jjtn000 = new ASTResources(this, JJTRESOURCES);
5205  12 boolean jjtc000 = true;
5206  12 jjtree.openNodeScope(jjtn000);
5207  12 try {
5208  12 Resource();
5209  12 label_50:
5210    while (true) {
5211  15 if (jj_2_49(2)) {
5212  3 ;
5213    } else {
5214  12 break label_50;
5215    }
5216  3 jj_consume_token(SEMICOLON);
5217  3 Resource();
5218    }
5219    } catch (Throwable jjte000) {
5220  0 if (jjtc000) {
5221  0 jjtree.clearNodeScope(jjtn000);
5222  0 jjtc000 = false;
5223    } else {
5224  0 jjtree.popNode();
5225    }
5226  0 if (jjte000 instanceof RuntimeException) {
5227  0 {if (true) throw (RuntimeException)jjte000;}
5228    }
5229  0 if (jjte000 instanceof ParseException) {
5230  0 {if (true) throw (ParseException)jjte000;}
5231    }
5232  0 {if (true) throw (Error)jjte000;}
5233    } finally {
5234  12 if (jjtc000) {
5235  12 jjtree.closeNodeScope(jjtn000, true);
5236    }
5237    }
5238    }
5239   
 
5240  15 toggle final public void Resource() throws ParseException {
5241    /*@bgen(jjtree) Resource */
5242  15 ASTResource jjtn000 = new ASTResource(this, JJTRESOURCE);
5243  15 boolean jjtc000 = true;
5244  15 jjtree.openNodeScope(jjtn000);
5245  15 try {
5246  15 label_51:
5247    while (true) {
5248  21 switch (jj_nt.kind) {
5249  3 case FINAL:
5250  3 case AT:
5251  6 ;
5252  6 break;
5253  15 default:
5254  15 jj_la1[128] = jj_gen;
5255  15 break label_51;
5256    }
5257  6 switch (jj_nt.kind) {
5258  3 case FINAL:
5259  3 jj_consume_token(FINAL);
5260  3 break;
5261  3 case AT:
5262  3 Annotation();
5263  3 break;
5264  0 default:
5265  0 jj_la1[129] = jj_gen;
5266  0 jj_consume_token(-1);
5267  0 throw new ParseException();
5268    }
5269    }
5270  15 Type();
5271  15 VariableDeclaratorId();
5272  15 jj_consume_token(ASSIGN);
5273  15 Expression();
5274    } catch (Throwable jjte000) {
5275  0 if (jjtc000) {
5276  0 jjtree.clearNodeScope(jjtn000);
5277  0 jjtc000 = false;
5278    } else {
5279  0 jjtree.popNode();
5280    }
5281  0 if (jjte000 instanceof RuntimeException) {
5282  0 {if (true) throw (RuntimeException)jjte000;}
5283    }
5284  0 if (jjte000 instanceof ParseException) {
5285  0 {if (true) throw (ParseException)jjte000;}
5286    }
5287  0 {if (true) throw (Error)jjte000;}
5288    } finally {
5289  15 if (jjtc000) {
5290  15 jjtree.closeNodeScope(jjtn000, true);
5291    }
5292    }
5293    }
5294   
 
5295  1878 toggle final public void CatchStatement() throws ParseException {
5296    /*@bgen(jjtree) CatchStatement */
5297  1878 ASTCatchStatement jjtn000 = new ASTCatchStatement(this, JJTCATCHSTATEMENT);
5298  1878 boolean jjtc000 = true;
5299  1878 jjtree.openNodeScope(jjtn000);
5300  1878 try {
5301  1878 jj_consume_token(CATCH);
5302  1878 jj_consume_token(LPAREN);
5303  1878 FormalParameter();
5304  1878 jj_consume_token(RPAREN);
5305  1878 Block();
5306    } catch (Throwable jjte000) {
5307  0 if (jjtc000) {
5308  0 jjtree.clearNodeScope(jjtn000);
5309  0 jjtc000 = false;
5310    } else {
5311  0 jjtree.popNode();
5312    }
5313  0 if (jjte000 instanceof RuntimeException) {
5314  0 {if (true) throw (RuntimeException)jjte000;}
5315    }
5316  0 if (jjte000 instanceof ParseException) {
5317  0 {if (true) throw (ParseException)jjte000;}
5318    }
5319  0 {if (true) throw (Error)jjte000;}
5320    } finally {
5321  1878 if (jjtc000) {
5322  1878 jjtree.closeNodeScope(jjtn000, true);
5323    }
5324    }
5325    }
5326   
 
5327  726 toggle final public void FinallyStatement() throws ParseException {
5328    /*@bgen(jjtree) FinallyStatement */
5329  726 ASTFinallyStatement jjtn000 = new ASTFinallyStatement(this, JJTFINALLYSTATEMENT);
5330  726 boolean jjtc000 = true;
5331  726 jjtree.openNodeScope(jjtn000);
5332  726 try {
5333  726 jj_consume_token(FINALLY);
5334  726 Block();
5335    } catch (Throwable jjte000) {
5336  0 if (jjtc000) {
5337  0 jjtree.clearNodeScope(jjtn000);
5338  0 jjtc000 = false;
5339    } else {
5340  0 jjtree.popNode();
5341    }
5342  0 if (jjte000 instanceof RuntimeException) {
5343  0 {if (true) throw (RuntimeException)jjte000;}
5344    }
5345  0 if (jjte000 instanceof ParseException) {
5346  0 {if (true) throw (ParseException)jjte000;}
5347    }
5348  0 {if (true) throw (Error)jjte000;}
5349    } finally {
5350  726 if (jjtc000) {
5351  726 jjtree.closeNodeScope(jjtn000, true);
5352    }
5353    }
5354    }
5355   
 
5356  18 toggle final public void AssertStatement() throws ParseException {
5357    /*@bgen(jjtree) AssertStatement */
5358  18 ASTAssertStatement jjtn000 = new ASTAssertStatement(this, JJTASSERTSTATEMENT);
5359  18 boolean jjtc000 = true;
5360  18 jjtree.openNodeScope(jjtn000);if (jdkVersion <= 3) {
5361  0 throw new ParseException("Can't use 'assert' as a keyword when running in JDK 1.3 mode!");
5362    }
5363  18 try {
5364  18 jj_consume_token(IDENTIFIER);
5365  18 Expression();
5366  18 switch (jj_nt.kind) {
5367  6 case COLON:
5368  6 jj_consume_token(COLON);
5369  6 Expression();
5370  6 break;
5371  12 default:
5372  12 jj_la1[130] = jj_gen;
5373  12 ;
5374    }
5375  18 jj_consume_token(SEMICOLON);
5376    } catch (Throwable jjte000) {
5377  0 if (jjtc000) {
5378  0 jjtree.clearNodeScope(jjtn000);
5379  0 jjtc000 = false;
5380    } else {
5381  0 jjtree.popNode();
5382    }
5383  0 if (jjte000 instanceof RuntimeException) {
5384  0 {if (true) throw (RuntimeException)jjte000;}
5385    }
5386  0 if (jjte000 instanceof ParseException) {
5387  0 {if (true) throw (ParseException)jjte000;}
5388    }
5389  0 {if (true) throw (Error)jjte000;}
5390    } finally {
5391  18 if (jjtc000) {
5392  18 jjtree.closeNodeScope(jjtn000, true);
5393    }
5394    }
5395    }
5396   
5397    /* We use productions to match >>>, >> and > so that we can keep the
5398    * type declaration syntax with generics clean
5399    */
 
5400  18 toggle final public void RUNSIGNEDSHIFT() throws ParseException {
5401    /*@bgen(jjtree) RUNSIGNEDSHIFT */
5402  18 ASTRUNSIGNEDSHIFT jjtn000 = new ASTRUNSIGNEDSHIFT(this, JJTRUNSIGNEDSHIFT);
5403  18 boolean jjtc000 = true;
5404  18 jjtree.openNodeScope(jjtn000);
5405  18 try {
5406  18 if (getToken(1).kind == GT &&
5407    ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT) {
5408   
5409    } else {
5410  0 jj_consume_token(-1);
5411  0 throw new ParseException();
5412    }
5413  18 jj_consume_token(GT);
5414  18 jj_consume_token(GT);
5415  18 jj_consume_token(GT);
5416    } finally {
5417  18 if (jjtc000) {
5418  18 jjtree.closeNodeScope(jjtn000, true);
5419    }
5420    }
5421    }
5422   
 
5423  207 toggle final public void RSIGNEDSHIFT() throws ParseException {
5424    /*@bgen(jjtree) RSIGNEDSHIFT */
5425  207 ASTRSIGNEDSHIFT jjtn000 = new ASTRSIGNEDSHIFT(this, JJTRSIGNEDSHIFT);
5426  207 boolean jjtc000 = true;
5427  207 jjtree.openNodeScope(jjtn000);
5428  207 try {
5429  207 if (getToken(1).kind == GT &&
5430    ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT) {
5431   
5432    } else {
5433  0 jj_consume_token(-1);
5434  0 throw new ParseException();
5435    }
5436  207 jj_consume_token(GT);
5437  207 jj_consume_token(GT);
5438    } finally {
5439  207 if (jjtc000) {
5440  207 jjtree.closeNodeScope(jjtn000, true);
5441    }
5442    }
5443    }
5444   
5445    /* Annotation syntax follows. */
 
5446  4803 toggle final public void Annotation() throws ParseException {
5447    /*@bgen(jjtree) Annotation */
5448  4805 ASTAnnotation jjtn000 = new ASTAnnotation(this, JJTANNOTATION);
5449  4806 boolean jjtc000 = true;
5450  4805 jjtree.openNodeScope(jjtn000);
5451  4806 try {
5452  4805 if (jj_2_50(2147483647)) {
5453  111 NormalAnnotation();
5454  4695 } else if (jj_2_51(2147483647)) {
5455  357 SingleMemberAnnotation();
5456    } else {
5457  4337 switch (jj_nt.kind) {
5458  4337 case AT:
5459  4338 MarkerAnnotation();
5460  4331 break;
5461  0 default:
5462  0 jj_la1[131] = jj_gen;
5463  0 jj_consume_token(-1);
5464  0 throw new ParseException();
5465    }
5466    }
5467    } catch (Throwable jjte000) {
5468  3 if (jjtc000) {
5469  3 jjtree.clearNodeScope(jjtn000);
5470  3 jjtc000 = false;
5471    } else {
5472  0 jjtree.popNode();
5473    }
5474  3 if (jjte000 instanceof RuntimeException) {
5475  3 {if (true) throw (RuntimeException)jjte000;}
5476    }
5477  0 if (jjte000 instanceof ParseException) {
5478  0 {if (true) throw (ParseException)jjte000;}
5479    }
5480  0 {if (true) throw (Error)jjte000;}
5481    } finally {
5482  4806 if (jjtc000) {
5483  4802 jjtree.closeNodeScope(jjtn000, true);
5484    }
5485    }
5486    }
5487   
 
5488  111 toggle final public void NormalAnnotation() throws ParseException {
5489    /*@bgen(jjtree) NormalAnnotation */
5490  111 ASTNormalAnnotation jjtn000 = new ASTNormalAnnotation(this, JJTNORMALANNOTATION);
5491  111 boolean jjtc000 = true;
5492  111 jjtree.openNodeScope(jjtn000);
5493  111 try {
5494  111 jj_consume_token(AT);
5495  111 Name();
5496  111 jj_consume_token(LPAREN);
5497  111 switch (jj_nt.kind) {
5498  111 case IDENTIFIER:
5499  111 MemberValuePairs();
5500  111 break;
5501  0 default:
5502  0 jj_la1[132] = jj_gen;
5503  0 ;
5504    }
5505  111 jj_consume_token(RPAREN);
5506  111 jjtree.closeNodeScope(jjtn000, true);
5507  111 jjtc000 = false;
5508  111 checkForBadAnnotationUsage();
5509    } catch (Throwable jjte000) {
5510  0 if (jjtc000) {
5511  0 jjtree.clearNodeScope(jjtn000);
5512  0 jjtc000 = false;
5513    } else {
5514  0 jjtree.popNode();
5515    }
5516  0 if (jjte000 instanceof RuntimeException) {
5517  0 {if (true) throw (RuntimeException)jjte000;}
5518    }
5519  0 if (jjte000 instanceof ParseException) {
5520  0 {if (true) throw (ParseException)jjte000;}
5521    }
5522  0 {if (true) throw (Error)jjte000;}
5523    } finally {
5524  111 if (jjtc000) {
5525  0 jjtree.closeNodeScope(jjtn000, true);
5526    }
5527    }
5528    }
5529   
 
5530  4336 toggle final public void MarkerAnnotation() throws ParseException {
5531    /*@bgen(jjtree) MarkerAnnotation */
5532  4336 ASTMarkerAnnotation jjtn000 = new ASTMarkerAnnotation(this, JJTMARKERANNOTATION);
5533  4337 boolean jjtc000 = true;
5534  4338 jjtree.openNodeScope(jjtn000);
5535  4338 try {
5536  4337 jj_consume_token(AT);
5537  4337 Name();
5538  4337 jjtree.closeNodeScope(jjtn000, true);
5539  4338 jjtc000 = false;
5540  4338 checkForBadAnnotationUsage();
5541    } catch (Throwable jjte000) {
5542  3 if (jjtc000) {
5543  0 jjtree.clearNodeScope(jjtn000);
5544  0 jjtc000 = false;
5545    } else {
5546  3 jjtree.popNode();
5547    }
5548  3 if (jjte000 instanceof RuntimeException) {
5549  3 {if (true) throw (RuntimeException)jjte000;}
5550    }
5551  0 if (jjte000 instanceof ParseException) {
5552  0 {if (true) throw (ParseException)jjte000;}
5553    }
5554  0 {if (true) throw (Error)jjte000;}
5555    } finally {
5556  4337 if (jjtc000) {
5557  0 jjtree.closeNodeScope(jjtn000, true);
5558    }
5559    }
5560    }
5561   
 
5562  357 toggle final public void SingleMemberAnnotation() throws ParseException {
5563    /*@bgen(jjtree) SingleMemberAnnotation */
5564  357 ASTSingleMemberAnnotation jjtn000 = new ASTSingleMemberAnnotation(this, JJTSINGLEMEMBERANNOTATION);
5565  357 boolean jjtc000 = true;
5566  357 jjtree.openNodeScope(jjtn000);
5567  357 try {
5568  357 jj_consume_token(AT);
5569  357 Name();
5570  357 jj_consume_token(LPAREN);
5571  357 MemberValue();
5572  357 jj_consume_token(RPAREN);
5573  357 jjtree.closeNodeScope(jjtn000, true);
5574  357 jjtc000 = false;
5575  357 checkForBadAnnotationUsage();
5576    } catch (Throwable jjte000) {
5577  0 if (jjtc000) {
5578  0 jjtree.clearNodeScope(jjtn000);
5579  0 jjtc000 = false;
5580    } else {
5581  0 jjtree.popNode();
5582    }
5583  0 if (jjte000 instanceof RuntimeException) {
5584  0 {if (true) throw (RuntimeException)jjte000;}
5585    }
5586  0 if (jjte000 instanceof ParseException) {
5587  0 {if (true) throw (ParseException)jjte000;}
5588    }
5589  0 {if (true) throw (Error)jjte000;}
5590    } finally {
5591  357 if (jjtc000) {
5592  0 jjtree.closeNodeScope(jjtn000, true);
5593    }
5594    }
5595    }
5596   
 
5597  111 toggle final public void MemberValuePairs() throws ParseException {
5598    /*@bgen(jjtree) MemberValuePairs */
5599  111 ASTMemberValuePairs jjtn000 = new ASTMemberValuePairs(this, JJTMEMBERVALUEPAIRS);
5600  111 boolean jjtc000 = true;
5601  111 jjtree.openNodeScope(jjtn000);
5602  111 try {
5603  111 MemberValuePair();
5604  111 label_52:
5605    while (true) {
5606  114 switch (jj_nt.kind) {
5607  3 case COMMA:
5608  3 ;
5609  3 break;
5610  111 default:
5611  111 jj_la1[133] = jj_gen;
5612  111 break label_52;
5613    }
5614  3 jj_consume_token(COMMA);
5615  3 MemberValuePair();
5616    }
5617    } catch (Throwable jjte000) {
5618  0 if (jjtc000) {
5619  0 jjtree.clearNodeScope(jjtn000);
5620  0 jjtc000 = false;
5621    } else {
5622  0 jjtree.popNode();
5623    }
5624  0 if (jjte000 instanceof RuntimeException) {
5625  0 {if (true) throw (RuntimeException)jjte000;}
5626    }
5627  0 if (jjte000 instanceof ParseException) {
5628  0 {if (true) throw (ParseException)jjte000;}
5629    }
5630  0 {if (true) throw (Error)jjte000;}
5631    } finally {
5632  111 if (jjtc000) {
5633  111 jjtree.closeNodeScope(jjtn000, true);
5634    }
5635    }
5636    }
5637   
 
5638  114 toggle final public void MemberValuePair() throws ParseException {
5639    /*@bgen(jjtree) MemberValuePair */
5640  114 ASTMemberValuePair jjtn000 = new ASTMemberValuePair(this, JJTMEMBERVALUEPAIR);
5641  114 boolean jjtc000 = true;
5642  114 jjtree.openNodeScope(jjtn000);Token t;
5643  114 try {
5644  114 t = jj_consume_token(IDENTIFIER);
5645  114 jjtn000.setImage(t.image);
5646  114 jj_consume_token(ASSIGN);
5647  114 MemberValue();
5648    } catch (Throwable jjte000) {
5649  0 if (jjtc000) {
5650  0 jjtree.clearNodeScope(jjtn000);
5651  0 jjtc000 = false;
5652    } else {
5653  0 jjtree.popNode();
5654    }
5655  0 if (jjte000 instanceof RuntimeException) {
5656  0 {if (true) throw (RuntimeException)jjte000;}
5657    }
5658  0 if (jjte000 instanceof ParseException) {
5659  0 {if (true) throw (ParseException)jjte000;}
5660    }
5661  0 {if (true) throw (Error)jjte000;}
5662    } finally {
5663  114 if (jjtc000) {
5664  114 jjtree.closeNodeScope(jjtn000, true);
5665    }
5666    }
5667    }
5668   
 
5669  528 toggle final public void MemberValue() throws ParseException {
5670    /*@bgen(jjtree) MemberValue */
5671  528 ASTMemberValue jjtn000 = new ASTMemberValue(this, JJTMEMBERVALUE);
5672  528 boolean jjtc000 = true;
5673  528 jjtree.openNodeScope(jjtn000);
5674  528 try {
5675  528 switch (jj_nt.kind) {
5676  0 case AT:
5677  0 Annotation();
5678  0 break;
5679  18 case LBRACE:
5680  18 MemberValueArrayInitializer();
5681  18 break;
5682  0 case BOOLEAN:
5683  0 case BYTE:
5684  0 case CHAR:
5685  0 case DOUBLE:
5686  0 case FALSE:
5687  0 case FLOAT:
5688  0 case INT:
5689  0 case LONG:
5690  0 case NEW:
5691  0 case NULL:
5692  0 case SHORT:
5693  0 case SUPER:
5694  0 case THIS:
5695  0 case TRUE:
5696  0 case VOID:
5697  0 case INTEGER_LITERAL:
5698  0 case FLOATING_POINT_LITERAL:
5699  0 case HEX_FLOATING_POINT_LITERAL:
5700  0 case CHARACTER_LITERAL:
5701  315 case STRING_LITERAL:
5702  195 case IDENTIFIER:
5703  0 case LPAREN:
5704  0 case BANG:
5705  0 case TILDE:
5706  0 case INCR:
5707  0 case DECR:
5708  0 case PLUS:
5709  0 case MINUS:
5710  510 ConditionalExpression();
5711  510 break;
5712  0 default:
5713  0 jj_la1[134] = jj_gen;
5714  0 jj_consume_token(-1);
5715  0 throw new ParseException();
5716    }
5717    } catch (Throwable jjte000) {
5718  0 if (jjtc000) {
5719  0 jjtree.clearNodeScope(jjtn000);
5720  0 jjtc000 = false;
5721    } else {
5722  0 jjtree.popNode();
5723    }
5724  0 if (jjte000 instanceof RuntimeException) {
5725  0 {if (true) throw (RuntimeException)jjte000;}
5726    }
5727  0 if (jjte000 instanceof ParseException) {
5728  0 {if (true) throw (ParseException)jjte000;}
5729    }
5730  0 {if (true) throw (Error)jjte000;}
5731    } finally {
5732  528 if (jjtc000) {
5733  528 jjtree.closeNodeScope(jjtn000, true);
5734    }
5735    }
5736    }
5737   
 
5738  18 toggle final public void MemberValueArrayInitializer() throws ParseException {
5739    /*@bgen(jjtree) MemberValueArrayInitializer */
5740  18 ASTMemberValueArrayInitializer jjtn000 = new ASTMemberValueArrayInitializer(this, JJTMEMBERVALUEARRAYINITIALIZER);
5741  18 boolean jjtc000 = true;
5742  18 jjtree.openNodeScope(jjtn000);
5743  18 try {
5744  18 jj_consume_token(LBRACE);
5745  18 switch (jj_nt.kind) {
5746  0 case BOOLEAN:
5747  0 case BYTE:
5748  0 case CHAR:
5749  0 case DOUBLE:
5750  0 case FALSE:
5751  0 case FLOAT:
5752  0 case INT:
5753  0 case LONG:
5754  0 case NEW:
5755  0 case NULL:
5756  0 case SHORT:
5757  0 case SUPER:
5758  0 case THIS:
5759  0 case TRUE:
5760  0 case VOID:
5761  0 case INTEGER_LITERAL:
5762  0 case FLOATING_POINT_LITERAL:
5763  0 case HEX_FLOATING_POINT_LITERAL:
5764  0 case CHARACTER_LITERAL:
5765  6 case STRING_LITERAL:
5766  12 case IDENTIFIER:
5767  0 case LPAREN:
5768  0 case LBRACE:
5769  0 case AT:
5770  0 case BANG:
5771  0 case TILDE:
5772  0 case INCR:
5773  0 case DECR:
5774  0 case PLUS:
5775  0 case MINUS:
5776  18 MemberValue();
5777  18 label_53:
5778    while (true) {
5779  57 if (jj_2_52(2)) {
5780  39 ;
5781    } else {
5782  18 break label_53;
5783    }
5784  39 jj_consume_token(COMMA);
5785  39 MemberValue();
5786    }
5787  18 switch (jj_nt.kind) {
5788  0 case COMMA:
5789  0 jj_consume_token(COMMA);
5790  0 break;
5791  18 default:
5792  18 jj_la1[135] = jj_gen;
5793  18 ;
5794    }
5795  18 break;
5796  0 default:
5797  0 jj_la1[136] = jj_gen;
5798  0 ;
5799    }
5800  18 jj_consume_token(RBRACE);
5801    } catch (Throwable jjte000) {
5802  0 if (jjtc000) {
5803  0 jjtree.clearNodeScope(jjtn000);
5804  0 jjtc000 = false;
5805    } else {
5806  0 jjtree.popNode();
5807    }
5808  0 if (jjte000 instanceof RuntimeException) {
5809  0 {if (true) throw (RuntimeException)jjte000;}
5810    }
5811  0 if (jjte000 instanceof ParseException) {
5812  0 {if (true) throw (ParseException)jjte000;}
5813    }
5814  0 {if (true) throw (Error)jjte000;}
5815    } finally {
5816  18 if (jjtc000) {
5817  18 jjtree.closeNodeScope(jjtn000, true);
5818    }
5819    }
5820    }
5821   
5822    /* Annotation Types. */
 
5823  18 toggle final public void AnnotationTypeDeclaration(int modifiers) throws ParseException {
5824    /*@bgen(jjtree) AnnotationTypeDeclaration */
5825  18 ASTAnnotationTypeDeclaration jjtn000 = new ASTAnnotationTypeDeclaration(this, JJTANNOTATIONTYPEDECLARATION);
5826  18 boolean jjtc000 = true;
5827  18 jjtree.openNodeScope(jjtn000);Token t;
5828  18 jjtn000.setModifiers(modifiers);
5829  18 try {
5830  18 jj_consume_token(AT);
5831  18 jj_consume_token(INTERFACE);
5832  18 t = jj_consume_token(IDENTIFIER);
5833  18 checkForBadAnnotationUsage();jjtn000.setImage(t.image);
5834  18 AnnotationTypeBody();
5835    } catch (Throwable jjte000) {
5836  0 if (jjtc000) {
5837  0 jjtree.clearNodeScope(jjtn000);
5838  0 jjtc000 = false;
5839    } else {
5840  0 jjtree.popNode();
5841    }
5842  0 if (jjte000 instanceof RuntimeException) {
5843  0 {if (true) throw (RuntimeException)jjte000;}
5844    }
5845  0 if (jjte000 instanceof ParseException) {
5846  0 {if (true) throw (ParseException)jjte000;}
5847    }
5848  0 {if (true) throw (Error)jjte000;}
5849    } finally {
5850  18 if (jjtc000) {
5851  18 jjtree.closeNodeScope(jjtn000, true);
5852    }
5853    }
5854    }
5855   
 
5856  18 toggle final public void AnnotationTypeBody() throws ParseException {
5857    /*@bgen(jjtree) AnnotationTypeBody */
5858  18 ASTAnnotationTypeBody jjtn000 = new ASTAnnotationTypeBody(this, JJTANNOTATIONTYPEBODY);
5859  18 boolean jjtc000 = true;
5860  18 jjtree.openNodeScope(jjtn000);
5861  18 try {
5862  18 jj_consume_token(LBRACE);
5863  18 label_54:
5864    while (true) {
5865  24 switch (jj_nt.kind) {
5866  0 case ABSTRACT:
5867  0 case BOOLEAN:
5868  0 case BYTE:
5869  0 case CHAR:
5870  0 case CLASS:
5871  0 case DOUBLE:
5872  0 case FINAL:
5873  0 case FLOAT:
5874  0 case INT:
5875  0 case INTERFACE:
5876  0 case LONG:
5877  0 case NATIVE:
5878  0 case PRIVATE:
5879  0 case PROTECTED:
5880  0 case PUBLIC:
5881  0 case SHORT:
5882  0 case STATIC:
5883  0 case SYNCHRONIZED:
5884  0 case TRANSIENT:
5885  0 case VOLATILE:
5886  0 case STRICTFP:
5887  6 case IDENTIFIER:
5888  0 case SEMICOLON:
5889  0 case AT:
5890  6 ;
5891  6 break;
5892  18 default:
5893  18 jj_la1[137] = jj_gen;
5894  18 break label_54;
5895    }
5896  6 AnnotationTypeMemberDeclaration();
5897    }
5898  18 jj_consume_token(RBRACE);
5899    } catch (Throwable jjte000) {
5900  0 if (jjtc000) {
5901  0 jjtree.clearNodeScope(jjtn000);
5902  0 jjtc000 = false;
5903    } else {
5904  0 jjtree.popNode();
5905    }
5906  0 if (jjte000 instanceof RuntimeException) {
5907  0 {if (true) throw (RuntimeException)jjte000;}
5908    }
5909  0 if (jjte000 instanceof ParseException) {
5910  0 {if (true) throw (ParseException)jjte000;}
5911    }
5912  0 {if (true) throw (Error)jjte000;}
5913    } finally {
5914  18 if (jjtc000) {
5915  18 jjtree.closeNodeScope(jjtn000, true);
5916    }
5917    }
5918    }
5919   
 
5920  6 toggle final public void AnnotationTypeMemberDeclaration() throws ParseException {
5921    /*@bgen(jjtree) AnnotationTypeMemberDeclaration */
5922  6 ASTAnnotationTypeMemberDeclaration jjtn000 = new ASTAnnotationTypeMemberDeclaration(this, JJTANNOTATIONTYPEMEMBERDECLARATION);
5923  6 boolean jjtc000 = true;
5924  6 jjtree.openNodeScope(jjtn000);int modifiers;
5925  6 try {
5926  6 switch (jj_nt.kind) {
5927  0 case ABSTRACT:
5928  0 case BOOLEAN:
5929  0 case BYTE:
5930  0 case CHAR:
5931  0 case CLASS:
5932  0 case DOUBLE:
5933  0 case FINAL:
5934  0 case FLOAT:
5935  0 case INT:
5936  0 case INTERFACE:
5937  0 case LONG:
5938  0 case NATIVE:
5939  0 case PRIVATE:
5940  0 case PROTECTED:
5941  0 case PUBLIC:
5942  0 case SHORT:
5943  0 case STATIC:
5944  0 case SYNCHRONIZED:
5945  0 case TRANSIENT:
5946  0 case VOLATILE:
5947  0 case STRICTFP:
5948  6 case IDENTIFIER:
5949  0 case AT:
5950  6 modifiers = Modifiers();
5951  6 if (jj_2_53(3)) {
5952  0 AnnotationMethodDeclaration(modifiers);
5953    } else {
5954  6 switch (jj_nt.kind) {
5955  0 case ABSTRACT:
5956  0 case CLASS:
5957  0 case FINAL:
5958  0 case INTERFACE:
5959  0 ClassOrInterfaceDeclaration(modifiers);
5960  0 break;
5961  6 default:
5962  6 jj_la1[138] = jj_gen;
5963  6 if (jj_2_54(3)) {
5964  0 EnumDeclaration(modifiers);
5965    } else {
5966  6 switch (jj_nt.kind) {
5967  0 case AT:
5968  0 AnnotationTypeDeclaration(modifiers);
5969  0 break;
5970  0 case BOOLEAN:
5971  0 case BYTE:
5972  0 case CHAR:
5973  0 case DOUBLE:
5974  0 case FLOAT:
5975  0 case INT:
5976  0 case LONG:
5977  0 case SHORT:
5978  6 case IDENTIFIER:
5979  6 FieldDeclaration(modifiers);
5980  6 break;
5981  0 default:
5982  0 jj_la1[139] = jj_gen;
5983  0 jj_consume_token(-1);
5984  0 throw new ParseException();
5985    }
5986    }
5987    }
5988    }
5989  6 break;
5990  0 case SEMICOLON:
5991  0 jj_consume_token(SEMICOLON);
5992  0 break;
5993  0 default:
5994  0 jj_la1[140] = jj_gen;
5995  0 jj_consume_token(-1);
5996  0 throw new ParseException();
5997    }
5998    } catch (Throwable jjte000) {
5999  0 if (jjtc000) {
6000  0 jjtree.clearNodeScope(jjtn000);
6001  0 jjtc000 = false;
6002    } else {
6003  0 jjtree.popNode();
6004    }
6005  0 if (jjte000 instanceof RuntimeException) {
6006  0 {if (true) throw (RuntimeException)jjte000;}
6007    }
6008  0 if (jjte000 instanceof ParseException) {
6009  0 {if (true) throw (ParseException)jjte000;}
6010    }
6011  0 {if (true) throw (Error)jjte000;}
6012    } finally {
6013  6 if (jjtc000) {
6014  6 jjtree.closeNodeScope(jjtn000, true);
6015    }
6016    }
6017    }
6018   
 
6019  0 toggle final public void AnnotationMethodDeclaration(int modifiers) throws ParseException {
6020    /*@bgen(jjtree) AnnotationMethodDeclaration */
6021  0 ASTAnnotationMethodDeclaration jjtn000 = new ASTAnnotationMethodDeclaration(this, JJTANNOTATIONMETHODDECLARATION);
6022  0 boolean jjtc000 = true;
6023  0 jjtree.openNodeScope(jjtn000);Token t;
6024  0 jjtn000.setModifiers(modifiers);
6025  0 try {
6026  0 Type();
6027  0 t = jj_consume_token(IDENTIFIER);
6028  0 jj_consume_token(LPAREN);
6029  0 jj_consume_token(RPAREN);
6030  0 switch (jj_nt.kind) {
6031  0 case _DEFAULT:
6032  0 DefaultValue();
6033  0 break;
6034  0 default:
6035  0 jj_la1[141] = jj_gen;
6036  0 ;
6037    }
6038  0 jj_consume_token(SEMICOLON);
6039  0 jjtree.closeNodeScope(jjtn000, true);
6040  0 jjtc000 = false;
6041  0 jjtn000.setImage(t.image);
6042    } catch (Throwable jjte000) {
6043  0 if (jjtc000) {
6044  0 jjtree.clearNodeScope(jjtn000);
6045  0 jjtc000 = false;
6046    } else {
6047  0 jjtree.popNode();
6048    }
6049  0 if (jjte000 instanceof RuntimeException) {
6050  0 {if (true) throw (RuntimeException)jjte000;}
6051    }
6052  0 if (jjte000 instanceof ParseException) {
6053  0 {if (true) throw (ParseException)jjte000;}
6054    }
6055  0 {if (true) throw (Error)jjte000;}
6056    } finally {
6057  0 if (jjtc000) {
6058  0 jjtree.closeNodeScope(jjtn000, true);
6059    }
6060    }
6061    }
6062   
 
6063  0 toggle final public void DefaultValue() throws ParseException {
6064    /*@bgen(jjtree) DefaultValue */
6065  0 ASTDefaultValue jjtn000 = new ASTDefaultValue(this, JJTDEFAULTVALUE);
6066  0 boolean jjtc000 = true;
6067  0 jjtree.openNodeScope(jjtn000);
6068  0 try {
6069  0 jj_consume_token(_DEFAULT);
6070  0 MemberValue();
6071    } catch (Throwable jjte000) {
6072  0 if (jjtc000) {
6073  0 jjtree.clearNodeScope(jjtn000);
6074  0 jjtc000 = false;
6075    } else {
6076  0 jjtree.popNode();
6077    }
6078  0 if (jjte000 instanceof RuntimeException) {
6079  0 {if (true) throw (RuntimeException)jjte000;}
6080    }
6081  0 if (jjte000 instanceof ParseException) {
6082  0 {if (true) throw (ParseException)jjte000;}
6083    }
6084  0 {if (true) throw (Error)jjte000;}
6085    } finally {
6086  0 if (jjtc000) {
6087  0 jjtree.closeNodeScope(jjtn000, true);
6088    }
6089    }
6090    }
6091   
 
6092  8947 toggle private boolean jj_2_1(int xla) {
6093  8949 jj_la = xla; jj_lastpos = jj_scanpos = token;
6094  8949 try { return !jj_3_1(); }
6095  0 catch(LookaheadSuccess ls) { return true; }
6096  8946 finally { jj_save(0, xla); }
6097    }
6098   
 
6099  117533 toggle private boolean jj_2_2(int xla) {
6100  117537 jj_la = xla; jj_lastpos = jj_scanpos = token;
6101  117535 try { return !jj_3_2(); }
6102  4760 catch(LookaheadSuccess ls) { return true; }
6103  117537 finally { jj_save(1, xla); }
6104    }
6105   
 
6106  225 toggle private boolean jj_2_3(int xla) {
6107  225 jj_la = xla; jj_lastpos = jj_scanpos = token;
6108  225 try { return !jj_3_3(); }
6109  180 catch(LookaheadSuccess ls) { return true; }
6110  225 finally { jj_save(2, xla); }
6111    }
6112   
 
6113  44338 toggle private boolean jj_2_4(int xla) {
6114  44342 jj_la = xla; jj_lastpos = jj_scanpos = token;
6115  44342 try { return !jj_3_4(); }
6116  561 catch(LookaheadSuccess ls) { return true; }
6117  44340 finally { jj_save(3, xla); }
6118    }
6119   
 
6120  43778 toggle private boolean jj_2_5(int xla) {
6121  43782 jj_la = xla; jj_lastpos = jj_scanpos = token;
6122  43782 try { return !jj_3_5(); }
6123  18 catch(LookaheadSuccess ls) { return true; }
6124  43781 finally { jj_save(4, xla); }
6125    }
6126   
 
6127  43760 toggle private boolean jj_2_6(int xla) {
6128  43762 jj_la = xla; jj_lastpos = jj_scanpos = token;
6129  43763 try { return !jj_3_6(); }
6130  0 catch(LookaheadSuccess ls) { return true; }
6131  43763 finally { jj_save(5, xla); }
6132    }
6133   
 
6134  40691 toggle private boolean jj_2_7(int xla) {
6135  40692 jj_la = xla; jj_lastpos = jj_scanpos = token;
6136  40692 try { return !jj_3_7(); }
6137  0 catch(LookaheadSuccess ls) { return true; }
6138  40690 finally { jj_save(6, xla); }
6139    }
6140   
 
6141  44593 toggle private boolean jj_2_8(int xla) {
6142  44598 jj_la = xla; jj_lastpos = jj_scanpos = token;
6143  44597 try { return !jj_3_8(); }
6144  0 catch(LookaheadSuccess ls) { return true; }
6145  44599 finally { jj_save(7, xla); }
6146    }
6147   
 
6148  11595 toggle private boolean jj_2_9(int xla) {
6149  11595 jj_la = xla; jj_lastpos = jj_scanpos = token;
6150  11595 try { return !jj_3_9(); }
6151  9807 catch(LookaheadSuccess ls) { return true; }
6152  11595 finally { jj_save(8, xla); }
6153    }
6154   
 
6155  3069 toggle private boolean jj_2_10(int xla) {
6156  3072 jj_la = xla; jj_lastpos = jj_scanpos = token;
6157  3072 try { return !jj_3_10(); }
6158  0 catch(LookaheadSuccess ls) { return true; }
6159  3067 finally { jj_save(9, xla); }
6160    }
6161   
 
6162  6397 toggle private boolean jj_2_11(int xla) {
6163  6399 jj_la = xla; jj_lastpos = jj_scanpos = token;
6164  6399 try { return !jj_3_11(); }
6165  3327 catch(LookaheadSuccess ls) { return true; }
6166  6397 finally { jj_save(10, xla); }
6167    }
6168   
 
6169  1512 toggle private boolean jj_2_12(int xla) {
6170  1515 jj_la = xla; jj_lastpos = jj_scanpos = token;
6171  1515 try { return !jj_3_12(); }
6172  0 catch(LookaheadSuccess ls) { return true; }
6173  1513 finally { jj_save(11, xla); }
6174    }
6175   
 
6176  1746 toggle private boolean jj_2_13(int xla) {
6177  1752 jj_la = xla; jj_lastpos = jj_scanpos = token;
6178  1752 try { return !jj_3_13(); }
6179  0 catch(LookaheadSuccess ls) { return true; }
6180  1750 finally { jj_save(12, xla); }
6181    }
6182   
 
6183  92361 toggle private boolean jj_2_14(int xla) {
6184  92373 jj_la = xla; jj_lastpos = jj_scanpos = token;
6185  92372 try { return !jj_3_14(); }
6186  12423 catch(LookaheadSuccess ls) { return true; }
6187  92371 finally { jj_save(13, xla); }
6188    }
6189   
 
6190  792 toggle private boolean jj_2_15(int xla) {
6191  792 jj_la = xla; jj_lastpos = jj_scanpos = token;
6192  792 try { return !jj_3_15(); }
6193  96 catch(LookaheadSuccess ls) { return true; }
6194  792 finally { jj_save(14, xla); }
6195    }
6196   
 
6197  77625 toggle private boolean jj_2_16(int xla) {
6198  77627 jj_la = xla; jj_lastpos = jj_scanpos = token;
6199  77629 try { return !jj_3_16(); }
6200  1911 catch(LookaheadSuccess ls) { return true; }
6201  77628 finally { jj_save(15, xla); }
6202    }
6203   
 
6204  92252 toggle private boolean jj_2_17(int xla) {
6205  92255 jj_la = xla; jj_lastpos = jj_scanpos = token;
6206  92258 try { return !jj_3_17(); }
6207  7944 catch(LookaheadSuccess ls) { return true; }
6208  92256 finally { jj_save(16, xla); }
6209    }
6210   
 
6211  96395 toggle private boolean jj_2_18(int xla) {
6212  96400 jj_la = xla; jj_lastpos = jj_scanpos = token;
6213  96398 try { return !jj_3_18(); }
6214  4143 catch(LookaheadSuccess ls) { return true; }
6215  96400 finally { jj_save(17, xla); }
6216    }
6217   
 
6218  4143 toggle private boolean jj_2_19(int xla) {
6219  4143 jj_la = xla; jj_lastpos = jj_scanpos = token;
6220  4142 try { return !jj_3_19(); }
6221  135 catch(LookaheadSuccess ls) { return true; }
6222  4143 finally { jj_save(18, xla); }
6223    }
6224   
 
6225  8106 toggle private boolean jj_2_20(int xla) {
6226  8106 jj_la = xla; jj_lastpos = jj_scanpos = token;
6227  8106 try { return !jj_3_20(); }
6228  8103 catch(LookaheadSuccess ls) { return true; }
6229  8106 finally { jj_save(19, xla); }
6230    }
6231   
 
6232  355609 toggle private boolean jj_2_21(int xla) {
6233  355694 jj_la = xla; jj_lastpos = jj_scanpos = token;
6234  355698 try { return !jj_3_21(); }
6235  145959 catch(LookaheadSuccess ls) { return true; }
6236  355683 finally { jj_save(20, xla); }
6237    }
6238   
 
6239  239078 toggle private boolean jj_2_22(int xla) {
6240  239074 jj_la = xla; jj_lastpos = jj_scanpos = token;
6241  239086 try { return !jj_3_22(); }
6242  522 catch(LookaheadSuccess ls) { return true; }
6243  239041 finally { jj_save(21, xla); }
6244    }
6245   
 
6246  225 toggle private boolean jj_2_23(int xla) {
6247  225 jj_la = xla; jj_lastpos = jj_scanpos = token;
6248  225 try { return !jj_3_23(); }
6249  207 catch(LookaheadSuccess ls) { return true; }
6250  225 finally { jj_save(22, xla); }
6251    }
6252   
 
6253  18 toggle private boolean jj_2_24(int xla) {
6254  18 jj_la = xla; jj_lastpos = jj_scanpos = token;
6255  18 try { return !jj_3_24(); }
6256  18 catch(LookaheadSuccess ls) { return true; }
6257  18 finally { jj_save(23, xla); }
6258    }
6259   
 
6260  264310 toggle private boolean jj_2_25(int xla) {
6261  264370 jj_la = xla; jj_lastpos = jj_scanpos = token;
6262  264357 try { return !jj_3_25(); }
6263  0 catch(LookaheadSuccess ls) { return true; }
6264  264387 finally { jj_save(24, xla); }
6265    }
6266   
 
6267  0 toggle private boolean jj_2_26(int xla) {
6268  0 jj_la = xla; jj_lastpos = jj_scanpos = token;
6269  0 try { return !jj_3_26(); }
6270  0 catch(LookaheadSuccess ls) { return true; }
6271  0 finally { jj_save(25, xla); }
6272    }
6273   
 
6274  0 toggle private boolean jj_2_27(int xla) {
6275  0 jj_la = xla; jj_lastpos = jj_scanpos = token;
6276  0 try { return !jj_3_27(); }
6277  0 catch(LookaheadSuccess ls) { return true; }
6278  0 finally { jj_save(26, xla); }
6279    }
6280   
 
6281  7998 toggle private boolean jj_2_28(int xla) {
6282  7998 jj_la = xla; jj_lastpos = jj_scanpos = token;
6283  7998 try { return !jj_3_28(); }
6284  0 catch(LookaheadSuccess ls) { return true; }
6285  7998 finally { jj_save(27, xla); }
6286    }
6287   
 
6288  407544 toggle private boolean jj_2_29(int xla) {
6289  407606 jj_la = xla; jj_lastpos = jj_scanpos = token;
6290  407567 try { return !jj_3_29(); }
6291  101787 catch(LookaheadSuccess ls) { return true; }
6292  407606 finally { jj_save(28, xla); }
6293    }
6294   
 
6295  183695 toggle private boolean jj_2_30(int xla) {
6296  183745 jj_la = xla; jj_lastpos = jj_scanpos = token;
6297  183726 try { return !jj_3_30(); }
6298  0 catch(LookaheadSuccess ls) { return true; }
6299  183758 finally { jj_save(29, xla); }
6300    }
6301   
 
6302  101764 toggle private boolean jj_2_31(int xla) {
6303  101780 jj_la = xla; jj_lastpos = jj_scanpos = token;
6304  101777 try { return !jj_3_31(); }
6305  12 catch(LookaheadSuccess ls) { return true; }
6306  101787 finally { jj_save(30, xla); }
6307    }
6308   
 
6309  101778 toggle private boolean jj_2_32(int xla) {
6310  101775 jj_la = xla; jj_lastpos = jj_scanpos = token;
6311  101777 try { return !jj_3_32(); }
6312  0 catch(LookaheadSuccess ls) { return true; }
6313  101771 finally { jj_save(31, xla); }
6314    }
6315   
 
6316  101776 toggle private boolean jj_2_33(int xla) {
6317  101788 jj_la = xla; jj_lastpos = jj_scanpos = token;
6318  101782 try { return !jj_3_33(); }
6319  0 catch(LookaheadSuccess ls) { return true; }
6320  101767 finally { jj_save(32, xla); }
6321    }
6322   
 
6323  101778 toggle private boolean jj_2_34(int xla) {
6324  101780 jj_la = xla; jj_lastpos = jj_scanpos = token;
6325  101776 try { return !jj_3_34(); }
6326  27 catch(LookaheadSuccess ls) { return true; }
6327  101778 finally { jj_save(33, xla); }
6328    }
6329   
 
6330  13541 toggle private boolean jj_2_35(int xla) {
6331  13542 jj_la = xla; jj_lastpos = jj_scanpos = token;
6332  13542 try { return !jj_3_35(); }
6333  228 catch(LookaheadSuccess ls) { return true; }
6334  13542 finally { jj_save(34, xla); }
6335    }
6336   
 
6337  447 toggle private boolean jj_2_36(int xla) {
6338  447 jj_la = xla; jj_lastpos = jj_scanpos = token;
6339  447 try { return !jj_3_36(); }
6340  3 catch(LookaheadSuccess ls) { return true; }
6341  447 finally { jj_save(35, xla); }
6342    }
6343   
 
6344  456 toggle private boolean jj_2_37(int xla) {
6345  456 jj_la = xla; jj_lastpos = jj_scanpos = token;
6346  456 try { return !jj_3_37(); }
6347  12 catch(LookaheadSuccess ls) { return true; }
6348  456 finally { jj_save(36, xla); }
6349    }
6350   
 
6351  1128 toggle private boolean jj_2_38(int xla) {
6352  1128 jj_la = xla; jj_lastpos = jj_scanpos = token;
6353  1128 try { return !jj_3_38(); }
6354  444 catch(LookaheadSuccess ls) { return true; }
6355  1128 finally { jj_save(37, xla); }
6356    }
6357   
 
6358  127010 toggle private boolean jj_2_39(int xla) {
6359  127035 jj_la = xla; jj_lastpos = jj_scanpos = token;
6360  127038 try { return !jj_3_39(); }
6361  261 catch(LookaheadSuccess ls) { return true; }
6362  127024 finally { jj_save(38, xla); }
6363    }
6364   
 
6365  153618 toggle private boolean jj_2_40(int xla) {
6366  153625 jj_la = xla; jj_lastpos = jj_scanpos = token;
6367  153629 try { return !jj_3_40(); }
6368  102394 catch(LookaheadSuccess ls) { return true; }
6369  153607 finally { jj_save(39, xla); }
6370    }
6371   
 
6372  117473 toggle private boolean jj_2_41(int xla) {
6373  117481 jj_la = xla; jj_lastpos = jj_scanpos = token;
6374  117481 try { return !jj_3_41(); }
6375  0 catch(LookaheadSuccess ls) { return true; }
6376  117478 finally { jj_save(40, xla); }
6377    }
6378   
 
6379  98789 toggle private boolean jj_2_42(int xla) {
6380  98791 jj_la = xla; jj_lastpos = jj_scanpos = token;
6381  98793 try { return !jj_3_42(); }
6382  98773 catch(LookaheadSuccess ls) { return true; }
6383  98794 finally { jj_save(41, xla); }
6384    }
6385   
 
6386  21 toggle private boolean jj_2_43(int xla) {
6387  21 jj_la = xla; jj_lastpos = jj_scanpos = token;
6388  21 try { return !jj_3_43(); }
6389  0 catch(LookaheadSuccess ls) { return true; }
6390  21 finally { jj_save(42, xla); }
6391    }
6392   
 
6393  48998 toggle private boolean jj_2_44(int xla) {
6394  48994 jj_la = xla; jj_lastpos = jj_scanpos = token;
6395  49001 try { return !jj_3_44(); }
6396  0 catch(LookaheadSuccess ls) { return true; }
6397  48995 finally { jj_save(43, xla); }
6398    }
6399   
 
6400  19995 toggle private boolean jj_2_45(int xla) {
6401  19995 jj_la = xla; jj_lastpos = jj_scanpos = token;
6402  19995 try { return !jj_3_45(); }
6403  11775 catch(LookaheadSuccess ls) { return true; }
6404  19994 finally { jj_save(44, xla); }
6405    }
6406   
 
6407  3423 toggle private boolean jj_2_46(int xla) {
6408  3423 jj_la = xla; jj_lastpos = jj_scanpos = token;
6409  3423 try { return !jj_3_46(); }
6410  0 catch(LookaheadSuccess ls) { return true; }
6411  3423 finally { jj_save(45, xla); }
6412    }
6413   
 
6414  1665 toggle private boolean jj_2_47(int xla) {
6415  1665 jj_la = xla; jj_lastpos = jj_scanpos = token;
6416  1665 try { return !jj_3_47(); }
6417  0 catch(LookaheadSuccess ls) { return true; }
6418  1665 finally { jj_save(46, xla); }
6419    }
6420   
 
6421  12 toggle private boolean jj_2_48(int xla) {
6422  12 jj_la = xla; jj_lastpos = jj_scanpos = token;
6423  12 try { return !jj_3_48(); }
6424  0 catch(LookaheadSuccess ls) { return true; }
6425  12 finally { jj_save(47, xla); }
6426    }
6427   
 
6428  15 toggle private boolean jj_2_49(int xla) {
6429  15 jj_la = xla; jj_lastpos = jj_scanpos = token;
6430  15 try { return !jj_3_49(); }
6431  3 catch(LookaheadSuccess ls) { return true; }
6432  15 finally { jj_save(48, xla); }
6433    }
6434   
 
6435  4803 toggle private boolean jj_2_50(int xla) {
6436  4805 jj_la = xla; jj_lastpos = jj_scanpos = token;
6437  4804 try { return !jj_3_50(); }
6438  0 catch(LookaheadSuccess ls) { return true; }
6439  4806 finally { jj_save(49, xla); }
6440    }
6441   
 
6442  4695 toggle private boolean jj_2_51(int xla) {
6443  4695 jj_la = xla; jj_lastpos = jj_scanpos = token;
6444  4695 try { return !jj_3_51(); }
6445  0 catch(LookaheadSuccess ls) { return true; }
6446  4695 finally { jj_save(50, xla); }
6447    }
6448   
 
6449  57 toggle private boolean jj_2_52(int xla) {
6450  57 jj_la = xla; jj_lastpos = jj_scanpos = token;
6451  57 try { return !jj_3_52(); }
6452  39 catch(LookaheadSuccess ls) { return true; }
6453  57 finally { jj_save(51, xla); }
6454    }
6455   
 
6456  6 toggle private boolean jj_2_53(int xla) {
6457  6 jj_la = xla; jj_lastpos = jj_scanpos = token;
6458  6 try { return !jj_3_53(); }
6459  0 catch(LookaheadSuccess ls) { return true; }
6460  6 finally { jj_save(52, xla); }
6461    }
6462   
 
6463  6 toggle private boolean jj_2_54(int xla) {
6464  6 jj_la = xla; jj_lastpos = jj_scanpos = token;
6465  6 try { return !jj_3_54(); }
6466  0 catch(LookaheadSuccess ls) { return true; }
6467  6 finally { jj_save(53, xla); }
6468    }
6469   
 
6470  55871 toggle private boolean jj_3R_257() {
6471  55884 if (jj_scan_token(RUNSIGNEDSHIFTASSIGN)) return true;
6472  0 return false;
6473    }
6474   
 
6475  55868 toggle private boolean jj_3R_256() {
6476  55883 if (jj_scan_token(RSIGNEDSHIFTASSIGN)) return true;
6477  0 return false;
6478    }
6479   
 
6480  55867 toggle private boolean jj_3R_255() {
6481  55882 if (jj_scan_token(LSHIFTASSIGN)) return true;
6482  0 return false;
6483    }
6484   
 
6485  55868 toggle private boolean jj_3R_254() {
6486  55884 if (jj_scan_token(MINUSASSIGN)) return true;
6487  0 return false;
6488    }
6489   
 
6490  55871 toggle private boolean jj_3R_253() {
6491  55884 if (jj_scan_token(PLUSASSIGN)) return true;
6492  0 return false;
6493    }
6494   
 
6495  55878 toggle private boolean jj_3R_252() {
6496  55883 if (jj_scan_token(REMASSIGN)) return true;
6497  0 return false;
6498    }
6499   
 
6500  55870 toggle private boolean jj_3R_251() {
6501  55884 if (jj_scan_token(SLASHASSIGN)) return true;
6502  0 return false;
6503    }
6504   
 
6505  55872 toggle private boolean jj_3R_250() {
6506  55884 if (jj_scan_token(STARASSIGN)) return true;
6507  0 return false;
6508    }
6509   
 
6510  55885 toggle private boolean jj_3R_239() {
6511  55893 Token xsp;
6512  55895 xsp = jj_scanpos;
6513  55901 if (jj_3R_249()) {
6514  55883 jj_scanpos = xsp;
6515  55881 if (jj_3R_250()) {
6516  55881 jj_scanpos = xsp;
6517  55883 if (jj_3R_251()) {
6518  55882 jj_scanpos = xsp;
6519  55883 if (jj_3R_252()) {
6520  55883 jj_scanpos = xsp;
6521  55882 if (jj_3R_253()) {
6522  55872 jj_scanpos = xsp;
6523  55882 if (jj_3R_254()) {
6524  55882 jj_scanpos = xsp;
6525  55880 if (jj_3R_255()) {
6526  55882 jj_scanpos = xsp;
6527  55882 if (jj_3R_256()) {
6528  55880 jj_scanpos = xsp;
6529  55882 if (jj_3R_257()) {
6530  55882 jj_scanpos = xsp;
6531  55880 if (jj_3R_258()) {
6532  55882 jj_scanpos = xsp;
6533  55883 if (jj_3R_259()) {
6534  55882 jj_scanpos = xsp;
6535  55880 if (jj_3R_260()) return true;
6536    }
6537    }
6538    }
6539    }
6540    }
6541    }
6542    }
6543    }
6544    }
6545    }
6546    }
6547  18 return false;
6548    }
6549   
 
6550  55890 toggle private boolean jj_3R_249() {
6551  55901 if (jj_scan_token(ASSIGN)) return true;
6552  18 return false;
6553    }
6554   
 
6555  55884 toggle private boolean jj_3R_229() {
6556  55897 if (jj_3R_239()) return true;
6557  0 if (jj_3R_92()) return true;
6558  18 return false;
6559    }
6560   
 
6561  168188 toggle private boolean jj_3R_92() {
6562  102345 if (jj_3R_146()) return true;
6563  55897 Token xsp;
6564  55898 xsp = jj_scanpos;
6565  55896 if (jj_3R_229()) jj_scanpos = xsp;
6566  55895 return false;
6567    }
6568   
 
6569  0 toggle private boolean jj_3R_339() {
6570  0 if (jj_scan_token(COMMA)) return true;
6571  0 if (jj_3R_100()) return true;
6572  0 return false;
6573    }
6574   
 
6575  0 toggle private boolean jj_3R_324() {
6576  0 if (jj_3R_100()) return true;
6577  0 Token xsp;
6578  0 while (true) {
6579  0 xsp = jj_scanpos;
6580  0 if (jj_3R_339()) { jj_scanpos = xsp; break; }
6581    }
6582  0 return false;
6583    }
6584   
 
6585  108292 toggle private boolean jj_3_19() {
6586  108167 if (jj_3R_81()) return true;
6587  129 return false;
6588    }
6589   
 
6590  474452 toggle private boolean jj_3_21() {
6591  474571 if (jj_scan_token(DOT)) return true;
6592  26988 if (jj_scan_token(IDENTIFIER)) return true;
6593  26654 return false;
6594    }
6595   
 
6596  6531 toggle private boolean jj_3R_268() {
6597  6531 if (jj_scan_token(COMMA)) return true;
6598  0 if (jj_3R_82()) return true;
6599  669 return false;
6600    }
6601   
 
6602  477949 toggle private boolean jj_3R_100() {
6603  473422 if (jj_scan_token(IDENTIFIER)) return true;
6604  92199 Token xsp;
6605  92192 while (true) {
6606  118862 xsp = jj_scanpos;
6607  118865 if (jj_3_21()) { jj_scanpos = xsp; break; }
6608    }
6609  92195 return false;
6610    }
6611   
 
6612  682818 toggle private boolean jj_3R_144() {
6613  648324 if (jj_3R_73()) return true;
6614  267127 return false;
6615    }
6616   
 
6617  682633 toggle private boolean jj_3R_89() {
6618  682725 Token xsp;
6619  683040 xsp = jj_scanpos;
6620  683050 if (jj_scan_token(59)) {
6621  682910 jj_scanpos = xsp;
6622  648368 if (jj_3R_144()) return true;
6623    }
6624  267303 return false;
6625    }
6626   
 
6627  1732157 toggle private boolean jj_3R_140() {
6628  1732087 if (jj_scan_token(DOUBLE)) return true;
6629  3993 return false;
6630    }
6631   
 
6632  1735158 toggle private boolean jj_3R_139() {
6633  1735206 if (jj_scan_token(FLOAT)) return true;
6634  2925 return false;
6635    }
6636   
 
6637  1739669 toggle private boolean jj_3R_138() {
6638  1739375 if (jj_scan_token(LONG)) return true;
6639  4122 return false;
6640    }
6641   
 
6642  1775877 toggle private boolean jj_3R_137() {
6643  1773949 if (jj_scan_token(INT)) return true;
6644  34189 return false;
6645    }
6646   
 
6647  1777825 toggle private boolean jj_3R_136() {
6648  1777967 if (jj_scan_token(SHORT)) return true;
6649  1680 return false;
6650    }
6651   
 
6652  1778953 toggle private boolean jj_3R_135() {
6653  1779664 if (jj_scan_token(BYTE)) return true;
6654  1683 return false;
6655    }
6656   
 
6657  1782275 toggle private boolean jj_3R_134() {
6658  1782282 if (jj_scan_token(CHAR)) return true;
6659  2595 return false;
6660    }
6661   
 
6662  1798946 toggle private boolean jj_3R_133() {
6663  1798535 if (jj_scan_token(BOOLEAN)) return true;
6664  16115 return false;
6665    }
6666   
 
6667  1798557 toggle private boolean jj_3R_87() {
6668  1799099 Token xsp;
6669  1799196 xsp = jj_scanpos;
6670  1798466 if (jj_3R_133()) {
6671  1782309 jj_scanpos = xsp;
6672  1782205 if (jj_3R_134()) {
6673  1779400 jj_scanpos = xsp;
6674  1779582 if (jj_3R_135()) {
6675  1777867 jj_scanpos = xsp;
6676  1777823 if (jj_3R_136()) {
6677  1776077 jj_scanpos = xsp;
6678  1773947 if (jj_3R_137()) {
6679  1739794 jj_scanpos = xsp;
6680  1739344 if (jj_3R_138()) {
6681  1735199 jj_scanpos = xsp;
6682  1735187 if (jj_3R_139()) {
6683  1732266 jj_scanpos = xsp;
6684  1732090 if (jj_3R_140()) return true;
6685    }
6686    }
6687    }
6688    }
6689    }
6690    }
6691    }
6692  67300 return false;
6693    }
6694   
 
6695  630 toggle private boolean jj_3R_290() {
6696  630 if (jj_scan_token(SUPER)) return true;
6697  0 if (jj_3R_80()) return true;
6698  0 return false;
6699    }
6700   
 
6701  690 toggle private boolean jj_3R_289() {
6702  690 if (jj_scan_token(EXTENDS)) return true;
6703  0 if (jj_3R_80()) return true;
6704  60 return false;
6705    }
6706   
 
6707  690 toggle private boolean jj_3R_276() {
6708  690 if (jj_3R_281()) return true;
6709  60 return false;
6710    }
6711   
 
6712  690 toggle private boolean jj_3R_281() {
6713  690 Token xsp;
6714  690 xsp = jj_scanpos;
6715  690 if (jj_3R_289()) {
6716  630 jj_scanpos = xsp;
6717  630 if (jj_3R_290()) return true;
6718    }
6719  60 return false;
6720    }
6721   
 
6722  3543 toggle private boolean jj_3R_128() {
6723  1407 if (jj_scan_token(HOOK)) return true;
6724  690 Token xsp;
6725  690 xsp = jj_scanpos;
6726  690 if (jj_3R_276()) jj_scanpos = xsp;
6727  690 return false;
6728    }
6729   
 
6730  503353 toggle private boolean jj_3_16() {
6731  501748 if (jj_scan_token(LBRACKET)) return true;
6732  7656 if (jj_scan_token(RBRACKET)) return true;
6733  1386 return false;
6734    }
6735   
 
6736  23454 toggle private boolean jj_3R_127() {
6737  9384 if (jj_3R_80()) return true;
6738  5841 return false;
6739    }
6740   
 
6741  23454 toggle private boolean jj_3R_82() {
6742  23454 Token xsp;
6743  23454 xsp = jj_scanpos;
6744  9384 if (jj_3R_127()) {
6745  3543 jj_scanpos = xsp;
6746  1407 if (jj_3R_128()) return true;
6747    }
6748  6531 return false;
6749    }
6750   
 
6751  652037 toggle private boolean jj_3R_126() {
6752  652196 if (jj_scan_token(LT)) return true;
6753  1833 if (jj_scan_token(GT)) return true;
6754  0 return false;
6755    }
6756   
 
6757  669835 toggle private boolean jj_3R_81() {
6758  670034 Token xsp;
6759  670045 xsp = jj_scanpos;
6760  656897 if (jj_3_20()) {
6761  652135 jj_scanpos = xsp;
6762  652174 if (jj_3R_126()) return true;
6763    }
6764  4740 return false;
6765    }
6766   
 
6767  678010 toggle private boolean jj_3_20() {
6768  673131 if (jj_scan_token(LT)) return true;
6769  6579 if (jj_3R_82()) return true;
6770  5862 Token xsp;
6771  5862 while (true) {
6772  6531 xsp = jj_scanpos;
6773  6531 if (jj_3R_268()) { jj_scanpos = xsp; break; }
6774    }
6775  5862 if (jj_scan_token(GT)) return true;
6776  4740 return false;
6777    }
6778   
 
6779  45261 toggle private boolean jj_3_15() {
6780  44572 if (jj_scan_token(LBRACKET)) return true;
6781  0 if (jj_scan_token(RBRACKET)) return true;
6782  732 return false;
6783    }
6784   
 
6785  0 toggle private boolean jj_3R_379() {
6786  0 if (jj_3R_388()) return true;
6787  0 return false;
6788    }
6789   
 
6790  631260 toggle private boolean jj_3_18() {
6791  626511 if (jj_scan_token(DOT)) return true;
6792  112405 if (jj_scan_token(IDENTIFIER)) return true;
6793  104162 Token xsp;
6794  104163 xsp = jj_scanpos;
6795  104158 if (jj_3_19()) jj_scanpos = xsp;
6796  104157 return false;
6797    }
6798   
 
6799  527979 toggle private boolean jj_3_17() {
6800  515176 if (jj_3R_81()) return true;
6801  4611 return false;
6802    }
6803   
 
6804  1162933 toggle private boolean jj_3R_187() {
6805  1058183 if (jj_scan_token(IDENTIFIER)) return true;
6806  435859 Token xsp;
6807  435889 xsp = jj_scanpos;
6808  430861 if (jj_3_17()) jj_scanpos = xsp;
6809  430858 while (true) {
6810  535027 xsp = jj_scanpos;
6811  530115 if (jj_3_18()) { jj_scanpos = xsp; break; }
6812    }
6813  425954 return false;
6814    }
6815   
 
6816  1161575 toggle private boolean jj_3R_125() {
6817  1046758 if (jj_3R_187()) return true;
6818  424456 Token xsp;
6819  424433 while (true) {
6820  425858 xsp = jj_scanpos;
6821  424120 if (jj_3_16()) { jj_scanpos = xsp; break; }
6822    }
6823  422714 return false;
6824    }
6825   
 
6826  1166525 toggle private boolean jj_3R_124() {
6827  1163479 if (jj_3R_87()) return true;
6828  43738 Token xsp;
6829  43050 if (jj_3_15()) return true;
6830  645 while (true) {
6831  732 xsp = jj_scanpos;
6832  732 if (jj_3_15()) { jj_scanpos = xsp; break; }
6833    }
6834  645 return false;
6835    }
6836   
 
6837  1166642 toggle private boolean jj_3R_80() {
6838  1167125 Token xsp;
6839  1167006 xsp = jj_scanpos;
6840  1162692 if (jj_3R_124()) {
6841  1161967 jj_scanpos = xsp;
6842  1044986 if (jj_3R_125()) return true;
6843    }
6844  423370 return false;
6845    }
6846   
 
6847  0 toggle private boolean jj_3R_304() {
6848  0 if (jj_scan_token(THROWS)) return true;
6849  0 if (jj_3R_324()) return true;
6850  0 return false;
6851    }
6852   
 
6853  594283 toggle private boolean jj_3R_114() {
6854  594513 if (jj_3R_87()) return true;
6855  18086 return false;
6856    }
6857   
 
6858  1050965 toggle private boolean jj_3R_73() {
6859  1051068 Token xsp;
6860  1051379 xsp = jj_scanpos;
6861  956151 if (jj_3_14()) {
6862  594378 jj_scanpos = xsp;
6863  594507 if (jj_3R_114()) return true;
6864    }
6865  379931 return false;
6866    }
6867   
 
6868  1143284 toggle private boolean jj_3_14() {
6869  1036231 if (jj_3R_80()) return true;
6870  417385 return false;
6871    }
6872   
 
6873  0 toggle private boolean jj_3R_388() {
6874  0 if (jj_scan_token(_DEFAULT)) return true;
6875  0 if (jj_3R_102()) return true;
6876  0 return false;
6877    }
6878   
 
6879  99 toggle private boolean jj_3R_363() {
6880  99 if (jj_3R_104()) return true;
6881  0 return false;
6882    }
6883   
 
6884  162 toggle private boolean jj_3R_295() {
6885  162 if (jj_scan_token(STATIC)) return true;
6886  0 return false;
6887    }
6888   
 
6889  1748 toggle private boolean jj_3_13() {
6890  1750 if (jj_scan_token(THIS)) return true;
6891  0 if (jj_3R_79()) return true;
6892  0 if (jj_scan_token(SEMICOLON)) return true;
6893  237 return false;
6894    }
6895   
 
6896  6 toggle private boolean jj_3R_103() {
6897  0 if (jj_3R_73()) return true;
6898  0 if (jj_scan_token(IDENTIFIER)) return true;
6899  6 if (jj_scan_token(LPAREN)) return true;
6900  0 if (jj_scan_token(RPAREN)) return true;
6901  0 Token xsp;
6902  0 xsp = jj_scanpos;
6903  0 if (jj_3R_379()) jj_scanpos = xsp;
6904  0 if (jj_scan_token(SEMICOLON)) return true;
6905  0 return false;
6906    }
6907   
 
6908  162 toggle private boolean jj_3R_284() {
6909  162 Token xsp;
6910  162 xsp = jj_scanpos;
6911  162 if (jj_3R_295()) jj_scanpos = xsp;
6912  162 if (jj_3R_190()) return true;
6913  0 return false;
6914    }
6915   
 
6916  3068 toggle private boolean jj_3_10() {
6917  3068 if (jj_3R_76()) return true;
6918  1752 return false;
6919    }
6920   
 
6921  4345 toggle private boolean jj_3_12() {
6922  4348 if (jj_3R_78()) return true;
6923  837 if (jj_scan_token(DOT)) return true;
6924  0 if (jj_scan_token(SUPER)) return true;
6925  0 if (jj_scan_token(LPAREN)) return true;
6926  0 return false;
6927    }
6928   
 
6929  2831 toggle private boolean jj_3R_118() {
6930  2835 Token xsp;
6931  2835 xsp = jj_scanpos;
6932  2834 if (jj_3_12()) jj_scanpos = xsp;
6933  2834 xsp = jj_scanpos;
6934  2835 if (jj_scan_token(50)) {
6935  1293 jj_scanpos = xsp;
6936  1293 if (jj_scan_token(53)) return true;
6937    }
6938  1939 if (jj_3R_79()) return true;
6939  0 if (jj_scan_token(SEMICOLON)) return true;
6940  1515 return false;
6941    }
6942   
 
6943  3070 toggle private boolean jj_3R_117() {
6944  3070 if (jj_scan_token(THIS)) return true;
6945  636 if (jj_3R_79()) return true;
6946  0 if (jj_scan_token(SEMICOLON)) return true;
6947  237 return false;
6948    }
6949   
 
6950  3068 toggle private boolean jj_3R_76() {
6951  3072 Token xsp;
6952  3072 xsp = jj_scanpos;
6953  3070 if (jj_3R_117()) {
6954  2834 jj_scanpos = xsp;
6955  2831 if (jj_3R_118()) return true;
6956    }
6957  1751 return false;
6958    }
6959   
 
6960  0 toggle private boolean jj_3R_366() {
6961  0 if (jj_3R_297()) return true;
6962  0 return false;
6963    }
6964   
 
6965  69 toggle private boolean jj_3R_338() {
6966  69 if (jj_scan_token(COMMA)) return true;
6967  0 if (jj_3R_337()) return true;
6968  9 return false;
6969    }
6970   
 
6971  6395 toggle private boolean jj_3_11() {
6972  3070 if (jj_3R_77()) return true;
6973  0 return false;
6974    }
6975   
 
6976  0 toggle private boolean jj_3R_365() {
6977  0 if (jj_3R_299()) return true;
6978  0 return false;
6979    }
6980   
 
6981  0 toggle private boolean jj_3R_305() {
6982  0 if (jj_3R_76()) return true;
6983  0 return false;
6984    }
6985   
 
6986  6 toggle private boolean jj_3_54() {
6987  6 if (jj_3R_71()) return true;
6988  0 return false;
6989    }
6990   
 
6991  162 toggle private boolean jj_3R_302() {
6992  162 if (jj_3R_113()) return true;
6993  0 return false;
6994    }
6995   
 
6996  0 toggle private boolean jj_3R_364() {
6997  0 if (jj_3R_70()) return true;
6998  0 return false;
6999    }
7000   
 
7001  162 toggle private boolean jj_3R_296() {
7002  162 Token xsp;
7003  162 xsp = jj_scanpos;
7004  162 if (jj_3R_302()) jj_scanpos = xsp;
7005  162 if (jj_scan_token(IDENTIFIER)) return true;
7006  3 if (jj_3R_303()) return true;
7007  0 xsp = jj_scanpos;
7008  0 if (jj_3R_304()) jj_scanpos = xsp;
7009  0 if (jj_scan_token(LBRACE)) return true;
7010  0 xsp = jj_scanpos;
7011  0 if (jj_3R_305()) jj_scanpos = xsp;
7012  0 while (true) {
7013  0 xsp = jj_scanpos;
7014  0 if (jj_3_11()) { jj_scanpos = xsp; break; }
7015    }
7016  0 if (jj_scan_token(RBRACE)) return true;
7017  0 return false;
7018    }
7019   
 
7020  6 toggle private boolean jj_3_53() {
7021  6 if (jj_3R_103()) return true;
7022  0 return false;
7023    }
7024   
 
7025  78 toggle private boolean jj_3R_351() {
7026  78 if (jj_scan_token(BIT_OR)) return true;
7027  0 if (jj_3R_73()) return true;
7028  0 return false;
7029    }
7030   
 
7031  0 toggle private boolean jj_3R_353() {
7032  0 if (jj_3R_98()) return true;
7033  0 Token xsp;
7034  0 xsp = jj_scanpos;
7035  0 if (jj_3_53()) {
7036  0 jj_scanpos = xsp;
7037  0 if (jj_3R_364()) {
7038  0 jj_scanpos = xsp;
7039  0 if (jj_3_54()) {
7040  0 jj_scanpos = xsp;
7041  0 if (jj_3R_365()) {
7042  0 jj_scanpos = xsp;
7043  0 if (jj_3R_366()) return true;
7044    }
7045    }
7046    }
7047    }
7048  0 return false;
7049    }
7050   
 
7051  0 toggle private boolean jj_3R_341() {
7052  0 Token xsp;
7053  0 xsp = jj_scanpos;
7054  0 if (jj_3R_353()) {
7055  0 jj_scanpos = xsp;
7056  0 if (jj_scan_token(82)) return true;
7057    }
7058  0 return false;
7059    }
7060   
 
7061  81 toggle private boolean jj_3R_327() {
7062  81 if (jj_scan_token(LBRACKET)) return true;
7063  0 if (jj_scan_token(RBRACKET)) return true;
7064  0 return false;
7065    }
7066   
 
7067  81 toggle private boolean jj_3R_310() {
7068  81 if (jj_scan_token(THROWS)) return true;
7069  0 if (jj_3R_324()) return true;
7070  0 return false;
7071    }
7072   
 
7073  0 toggle private boolean jj_3R_328() {
7074  0 if (jj_3R_341()) return true;
7075  0 return false;
7076    }
7077   
 
7078  78 toggle private boolean jj_3R_352() {
7079  78 if (jj_scan_token(ELLIPSIS)) return true;
7080  0 return false;
7081    }
7082   
 
7083  99 toggle private boolean jj_3R_362() {
7084  99 if (jj_scan_token(FINAL)) return true;
7085  0 return false;
7086    }
7087   
 
7088  99 toggle private boolean jj_3R_350() {
7089  99 Token xsp;
7090  99 xsp = jj_scanpos;
7091  99 if (jj_3R_362()) {
7092  99 jj_scanpos = xsp;
7093  99 if (jj_3R_363()) return true;
7094    }
7095  0 return false;
7096    }
7097   
 
7098  57 toggle private boolean jj_3_52() {
7099  57 if (jj_scan_token(COMMA)) return true;
7100  0 if (jj_3R_102()) return true;
7101  0 return false;
7102    }
7103   
 
7104  99 toggle private boolean jj_3R_337() {
7105  99 Token xsp;
7106  99 while (true) {
7107  99 xsp = jj_scanpos;
7108  99 if (jj_3R_350()) { jj_scanpos = xsp; break; }
7109    }
7110  99 if (jj_3R_73()) return true;
7111  78 while (true) {
7112  78 xsp = jj_scanpos;
7113  78 if (jj_3R_351()) { jj_scanpos = xsp; break; }
7114    }
7115  78 xsp = jj_scanpos;
7116  78 if (jj_3R_352()) jj_scanpos = xsp;
7117  0 if (jj_3R_325()) return true;
7118  78 return false;
7119    }
7120   
 
7121  0 toggle private boolean jj_3R_312() {
7122  0 if (jj_scan_token(LBRACE)) return true;
7123  0 Token xsp;
7124  0 while (true) {
7125  0 xsp = jj_scanpos;
7126  0 if (jj_3R_328()) { jj_scanpos = xsp; break; }
7127    }
7128  0 if (jj_scan_token(RBRACE)) return true;
7129  0 return false;
7130    }
7131   
 
7132  81 toggle private boolean jj_3R_323() {
7133  81 if (jj_3R_337()) return true;
7134  60 Token xsp;
7135  60 while (true) {
7136  69 xsp = jj_scanpos;
7137  69 if (jj_3R_338()) { jj_scanpos = xsp; break; }
7138    }
7139  60 return false;
7140    }
7141   
 
7142  11745 toggle private boolean jj_3_9() {
7143  11745 if (jj_scan_token(COMMA)) return true;
7144  222 if (jj_3R_75()) return true;
7145  69 return false;
7146    }
7147   
 
7148  78 toggle private boolean jj_3R_299() {
7149  78 if (jj_scan_token(AT)) return true;
7150  0 if (jj_scan_token(INTERFACE)) return true;
7151  0 if (jj_scan_token(IDENTIFIER)) return true;
7152  0 if (jj_3R_312()) return true;
7153  0 return false;
7154    }
7155   
 
7156  84 toggle private boolean jj_3R_303() {
7157  84 if (jj_scan_token(LPAREN)) return true;
7158  81 Token xsp;
7159  81 xsp = jj_scanpos;
7160  81 if (jj_3R_323()) jj_scanpos = xsp;
7161  0 if (jj_scan_token(RPAREN)) return true;
7162  81 return false;
7163    }
7164   
 
7165  0 toggle private boolean jj_3R_264() {
7166  0 if (jj_3R_102()) return true;
7167  0 Token xsp;
7168  0 while (true) {
7169  0 xsp = jj_scanpos;
7170  0 if (jj_3_52()) { jj_scanpos = xsp; break; }
7171    }
7172  0 xsp = jj_scanpos;
7173  0 if (jj_scan_token(83)) jj_scanpos = xsp;
7174  0 return false;
7175    }
7176   
 
7177  141 toggle private boolean jj_3R_205() {
7178  141 if (jj_scan_token(LBRACE)) return true;
7179  0 Token xsp;
7180  0 xsp = jj_scanpos;
7181  0 if (jj_3R_264()) jj_scanpos = xsp;
7182  0 if (jj_scan_token(RBRACE)) return true;
7183  0 return false;
7184    }
7185   
 
7186  6 toggle private boolean jj_3R_246() {
7187  6 if (jj_scan_token(COMMA)) return true;
7188  0 if (jj_3R_245()) return true;
7189  3 return false;
7190    }
7191   
 
7192  81 toggle private boolean jj_3R_309() {
7193  0 if (jj_scan_token(IDENTIFIER)) return true;
7194  0 if (jj_3R_303()) return true;
7195  81 Token xsp;
7196  81 while (true) {
7197  81 xsp = jj_scanpos;
7198  81 if (jj_3R_327()) { jj_scanpos = xsp; break; }
7199    }
7200  81 return false;
7201    }
7202   
 
7203  141 toggle private boolean jj_3R_166() {
7204  0 if (jj_3R_146()) return true;
7205  102 return false;
7206    }
7207   
 
7208  81 toggle private boolean jj_3R_311() {
7209  81 if (jj_3R_190()) return true;
7210  78 return false;
7211    }
7212   
 
7213  141 toggle private boolean jj_3R_165() {
7214  141 if (jj_3R_205()) return true;
7215  0 return false;
7216    }
7217   
 
7218  156 toggle private boolean jj_3R_308() {
7219  156 if (jj_3R_113()) return true;
7220  0 return false;
7221    }
7222   
 
7223  141 toggle private boolean jj_3R_102() {
7224  141 Token xsp;
7225  141 xsp = jj_scanpos;
7226  141 if (jj_3R_164()) {
7227  141 jj_scanpos = xsp;
7228  141 if (jj_3R_165()) {
7229  141 jj_scanpos = xsp;
7230  0 if (jj_3R_166()) return true;
7231    }
7232    }
7233  102 return false;
7234    }
7235   
 
7236  141 toggle private boolean jj_3R_164() {
7237  141 if (jj_3R_104()) return true;
7238  0 return false;
7239    }
7240   
 
7241  156 toggle private boolean jj_3R_298() {
7242  156 Token xsp;
7243  156 xsp = jj_scanpos;
7244  156 if (jj_3R_308()) jj_scanpos = xsp;
7245  156 if (jj_3R_89()) return true;
7246  0 if (jj_3R_309()) return true;
7247  81 xsp = jj_scanpos;
7248  81 if (jj_3R_310()) jj_scanpos = xsp;
7249  81 xsp = jj_scanpos;
7250  81 if (jj_3R_311()) {
7251  3 jj_scanpos = xsp;
7252  3 if (jj_scan_token(82)) return true;
7253    }
7254  78 return false;
7255    }
7256   
 
7257  81 toggle private boolean jj_3R_271() {
7258  0 if (jj_3R_75()) return true;
7259  81 Token xsp;
7260  81 while (true) {
7261  150 xsp = jj_scanpos;
7262  150 if (jj_3_9()) { jj_scanpos = xsp; break; }
7263    }
7264  81 return false;
7265    }
7266   
 
7267  102 toggle private boolean jj_3R_245() {
7268  102 if (jj_scan_token(IDENTIFIER)) return true;
7269  18 if (jj_scan_token(ASSIGN)) return true;
7270  0 if (jj_3R_102()) return true;
7271  6 return false;
7272    }
7273   
 
7274  48 toggle private boolean jj_3R_326() {
7275  48 if (jj_scan_token(ASSIGN)) return true;
7276  0 if (jj_3R_75()) return true;
7277  30 return false;
7278    }
7279   
 
7280  10221 toggle private boolean jj_3R_175() {
7281  9585 if (jj_scan_token(LBRACE)) return true;
7282  81 Token xsp;
7283  81 xsp = jj_scanpos;
7284  0 if (jj_3R_271()) jj_scanpos = xsp;
7285  81 xsp = jj_scanpos;
7286  81 if (jj_scan_token(83)) jj_scanpos = xsp;
7287  0 if (jj_scan_token(RBRACE)) return true;
7288  81 return false;
7289    }
7290   
 
7291  21 toggle private boolean jj_3R_307() {
7292  21 if (jj_scan_token(COMMA)) return true;
7293  0 if (jj_3R_306()) return true;
7294  0 return false;
7295    }
7296   
 
7297  28920 toggle private boolean jj_3R_74() {
7298  28922 if (jj_scan_token(LBRACKET)) return true;
7299  0 if (jj_scan_token(RBRACKET)) return true;
7300  15 return false;
7301    }
7302   
 
7303  99 toggle private boolean jj_3R_234() {
7304  99 if (jj_3R_245()) return true;
7305  3 Token xsp;
7306  3 while (true) {
7307  6 xsp = jj_scanpos;
7308  6 if (jj_3R_246()) { jj_scanpos = xsp; break; }
7309    }
7310  3 return false;
7311    }
7312   
 
7313  9504 toggle private boolean jj_3R_116() {
7314  333 if (jj_3R_92()) return true;
7315  180 return false;
7316    }
7317   
 
7318  99 toggle private boolean jj_3R_218() {
7319  99 if (jj_3R_234()) return true;
7320  3 return false;
7321    }
7322   
 
7323  10140 toggle private boolean jj_3R_115() {
7324  9504 if (jj_3R_175()) return true;
7325  0 return false;
7326    }
7327   
 
7328  10140 toggle private boolean jj_3R_75() {
7329  10140 Token xsp;
7330  10140 xsp = jj_scanpos;
7331  9504 if (jj_3R_115()) {
7332  9504 jj_scanpos = xsp;
7333  333 if (jj_3R_116()) return true;
7334    }
7335  180 return false;
7336    }
7337   
 
7338  468 toggle private boolean jj_3R_101() {
7339  468 if (jj_scan_token(IDENTIFIER)) return true;
7340  150 if (jj_scan_token(ASSIGN)) return true;
7341  111 return false;
7342    }
7343   
 
7344  427663 toggle private boolean jj_3R_207() {
7345  427825 if (jj_scan_token(AT)) return true;
7346  123 if (jj_3R_100()) return true;
7347  105 if (jj_scan_token(LPAREN)) return true;
7348  0 if (jj_3R_102()) return true;
7349  0 if (jj_scan_token(RPAREN)) return true;
7350  96 return false;
7351    }
7352   
 
7353  0 toggle private boolean jj_3R_349() {
7354  0 if (jj_3R_110()) return true;
7355  0 return false;
7356    }
7357   
 
7358  126 toggle private boolean jj_3R_340() {
7359  126 if (jj_scan_token(LBRACKET)) return true;
7360  0 if (jj_scan_token(RBRACKET)) return true;
7361  0 return false;
7362    }
7363   
 
7364  427586 toggle private boolean jj_3R_208() {
7365  427754 if (jj_scan_token(AT)) return true;
7366  27 if (jj_3R_100()) return true;
7367  9 return false;
7368    }
7369   
 
7370  213 toggle private boolean jj_3R_325() {
7371  213 if (jj_scan_token(IDENTIFIER)) return true;
7372  126 Token xsp;
7373  126 while (true) {
7374  126 xsp = jj_scanpos;
7375  126 if (jj_3R_340()) { jj_scanpos = xsp; break; }
7376    }
7377  126 return false;
7378    }
7379   
 
7380  174 toggle private boolean jj_3R_174() {
7381  174 if (jj_scan_token(COMMA)) return true;
7382  0 if (jj_3R_173()) return true;
7383  9 return false;
7384    }
7385   
 
7386  174 toggle private boolean jj_3R_209() {
7387  174 if (jj_3R_219()) return true;
7388  12 return false;
7389    }
7390   
 
7391  4692 toggle private boolean jj_3_51() {
7392  0 if (jj_scan_token(AT)) return true;
7393  0 if (jj_3R_100()) return true;
7394  4694 if (jj_scan_token(LPAREN)) return true;
7395  357 return false;
7396    }
7397   
 
7398  432451 toggle private boolean jj_3R_206() {
7399  432599 if (jj_scan_token(AT)) return true;
7400  126 if (jj_3R_100()) return true;
7401  108 if (jj_scan_token(LPAREN)) return true;
7402  99 Token xsp;
7403  99 xsp = jj_scanpos;
7404  99 if (jj_3R_218()) jj_scanpos = xsp;
7405  99 if (jj_scan_token(RPAREN)) return true;
7406  3 return false;
7407    }
7408   
 
7409  12 toggle private boolean jj_3R_235() {
7410  12 if (jj_scan_token(BIT_AND)) return true;
7411  0 if (jj_3R_187()) return true;
7412  0 return false;
7413    }
7414   
 
7415  4803 toggle private boolean jj_3_50() {
7416  0 if (jj_scan_token(AT)) return true;
7417  0 if (jj_3R_100()) return true;
7418  4806 if (jj_scan_token(LPAREN)) return true;
7419  468 Token xsp;
7420  468 xsp = jj_scanpos;
7421  468 if (jj_3R_101()) {
7422  357 jj_scanpos = xsp;
7423  357 if (jj_scan_token(77)) return true;
7424    }
7425  111 return false;
7426    }
7427   
 
7428  135 toggle private boolean jj_3R_306() {
7429  135 if (jj_3R_325()) return true;
7430  48 Token xsp;
7431  48 xsp = jj_scanpos;
7432  48 if (jj_3R_326()) jj_scanpos = xsp;
7433  48 return false;
7434    }
7435   
 
7436  43758 toggle private boolean jj_3R_72() {
7437  43764 if (jj_3R_113()) return true;
7438  165 return false;
7439    }
7440   
 
7441  40687 toggle private boolean jj_3_7() {
7442  40691 if (jj_3R_73()) return true;
7443  0 if (jj_scan_token(IDENTIFIER)) return true;
7444  28908 Token xsp;
7445  28908 while (true) {
7446  28923 xsp = jj_scanpos;
7447  28922 if (jj_3R_74()) { jj_scanpos = xsp; break; }
7448    }
7449  28907 xsp = jj_scanpos;
7450  28908 if (jj_scan_token(83)) {
7451  28881 jj_scanpos = xsp;
7452  28881 if (jj_scan_token(86)) {
7453  19191 jj_scanpos = xsp;
7454  19191 if (jj_scan_token(82)) return true;
7455    }
7456    }
7457  13593 return false;
7458    }
7459   
 
7460  43756 toggle private boolean jj_3_6() {
7461  43762 Token xsp;
7462  43762 xsp = jj_scanpos;
7463  43764 if (jj_3R_72()) jj_scanpos = xsp;
7464  43764 if (jj_scan_token(IDENTIFIER)) return true;
7465  20367 if (jj_scan_token(LPAREN)) return true;
7466  3072 return false;
7467    }
7468   
 
7469  427621 toggle private boolean jj_3R_169() {
7470  427754 if (jj_3R_208()) return true;
7471  9 return false;
7472    }
7473   
 
7474  162 toggle private boolean jj_3R_297() {
7475  162 if (jj_3R_73()) return true;
7476  0 if (jj_3R_306()) return true;
7477  21 Token xsp;
7478  21 while (true) {
7479  21 xsp = jj_scanpos;
7480  21 if (jj_3R_307()) { jj_scanpos = xsp; break; }
7481    }
7482  21 if (jj_scan_token(SEMICOLON)) return true;
7483  6 return false;
7484    }
7485   
 
7486  180 toggle private boolean jj_3R_68() {
7487  180 if (jj_3R_104()) return true;
7488  0 return false;
7489    }
7490   
 
7491  0 toggle private boolean jj_3R_348() {
7492  0 if (jj_3R_79()) return true;
7493  0 return false;
7494    }
7495   
 
7496  427704 toggle private boolean jj_3R_168() {
7497  427845 if (jj_3R_207()) return true;
7498  96 return false;
7499    }
7500   
 
7501  106612 toggle private boolean jj_3R_106() {
7502  106620 if (jj_scan_token(INTERFACE)) return true;
7503  48 return false;
7504    }
7505   
 
7506  414 toggle private boolean jj_3R_129() {
7507  414 return false;
7508    }
7509   
 
7510  432475 toggle private boolean jj_3R_104() {
7511  432611 Token xsp;
7512  432611 xsp = jj_scanpos;
7513  427854 if (jj_3R_167()) {
7514  427824 jj_scanpos = xsp;
7515  427847 if (jj_3R_168()) {
7516  427722 jj_scanpos = xsp;
7517  427738 if (jj_3R_169()) return true;
7518    }
7519    }
7520  108 return false;
7521    }
7522   
 
7523  432470 toggle private boolean jj_3R_167() {
7524  427834 if (jj_3R_206()) return true;
7525  3 return false;
7526    }
7527   
 
7528  78 toggle private boolean jj_3R_288() {
7529  78 if (jj_3R_299()) return true;
7530  0 return false;
7531    }
7532   
 
7533  156 toggle private boolean jj_3R_287() {
7534  156 if (jj_3R_298()) return true;
7535  78 return false;
7536    }
7537   
 
7538  44590 toggle private boolean jj_3_8() {
7539  44599 Token xsp;
7540  44600 xsp = jj_scanpos;
7541  44598 if (jj_scan_token(49)) jj_scanpos = xsp;
7542  44600 if (jj_scan_token(LBRACE)) return true;
7543  126 return false;
7544    }
7545   
 
7546  0 toggle private boolean jj_3R_360() {
7547  0 if (jj_scan_token(COLON)) return true;
7548  0 if (jj_3R_92()) return true;
7549  0 return false;
7550    }
7551   
 
7552  162 toggle private boolean jj_3R_286() {
7553  162 if (jj_3R_297()) return true;
7554  6 return false;
7555    }
7556   
 
7557  162 toggle private boolean jj_3R_285() {
7558  162 if (jj_3R_296()) return true;
7559  0 return false;
7560    }
7561   
 
7562  43939 toggle private boolean jj_3_5() {
7563  43925 if (jj_3R_71()) return true;
7564  0 return false;
7565    }
7566   
 
7567  44498 toggle private boolean jj_3_4() {
7568  43943 if (jj_3R_70()) return true;
7569  0 return false;
7570    }
7571   
 
7572  36 toggle private boolean jj_3R_130() {
7573  36 return false;
7574    }
7575   
 
7576  162 toggle private boolean jj_3R_280() {
7577  0 if (jj_3R_98()) return true;
7578  162 Token xsp;
7579  162 xsp = jj_scanpos;
7580  162 if (jj_3_4()) {
7581  162 jj_scanpos = xsp;
7582  162 if (jj_3_5()) {
7583  162 jj_scanpos = xsp;
7584  162 if (jj_3R_285()) {
7585  162 jj_scanpos = xsp;
7586  162 if (jj_3R_286()) {
7587  156 jj_scanpos = xsp;
7588  156 if (jj_3R_287()) {
7589  78 jj_scanpos = xsp;
7590  78 if (jj_3R_288()) return true;
7591    }
7592    }
7593    }
7594    }
7595    }
7596  84 return false;
7597    }
7598   
 
7599  162 toggle private boolean jj_3R_275() {
7600  162 Token xsp;
7601  162 xsp = jj_scanpos;
7602  162 if (jj_3R_279()) {
7603  162 jj_scanpos = xsp;
7604  162 if (jj_3R_280()) {
7605  78 jj_scanpos = xsp;
7606  78 if (jj_scan_token(82)) return true;
7607    }
7608    }
7609  84 return false;
7610    }
7611   
 
7612  162 toggle private boolean jj_3R_279() {
7613  162 if (jj_3R_284()) return true;
7614  0 return false;
7615    }
7616   
 
7617  295169 toggle private boolean jj_3R_84() {
7618  295373 jj_lookingAhead = true;
7619  295413 jj_semLA = getToken(1).kind == GT &&
7620    ((Token.GTToken)getToken(1)).realKind == RSIGNEDSHIFT;
7621  295388 jj_lookingAhead = false;
7622  295411 if (!jj_semLA || jj_3R_129()) return true;
7623  0 if (jj_scan_token(GT)) return true;
7624  0 if (jj_scan_token(GT)) return true;
7625  0 return false;
7626    }
7627   
 
7628  162 toggle private boolean jj_3R_272() {
7629  162 if (jj_3R_275()) return true;
7630  84 return false;
7631    }
7632   
 
7633  225 toggle private boolean jj_3_3() {
7634  225 if (jj_scan_token(COMMA)) return true;
7635  180 Token xsp;
7636  180 while (true) {
7637  180 xsp = jj_scanpos;
7638  180 if (jj_3R_68()) { jj_scanpos = xsp; break; }
7639    }
7640  0 if (jj_3R_69()) return true;
7641  0 return false;
7642    }
7643   
 
7644  1716 toggle private boolean jj_3R_110() {
7645  1371 if (jj_scan_token(LBRACE)) return true;
7646  78 Token xsp;
7647  78 while (true) {
7648  162 xsp = jj_scanpos;
7649  162 if (jj_3R_272()) { jj_scanpos = xsp; break; }
7650    }
7651  78 if (jj_scan_token(RBRACE)) return true;
7652  75 return false;
7653    }
7654   
 
7655  294701 toggle private boolean jj_3R_85() {
7656  294910 jj_lookingAhead = true;
7657  294873 jj_semLA = getToken(1).kind == GT &&
7658    ((Token.GTToken)getToken(1)).realKind == RUNSIGNEDSHIFT;
7659  294951 jj_lookingAhead = false;
7660  294949 if (!jj_semLA || jj_3R_130()) return true;
7661  0 if (jj_scan_token(GT)) return true;
7662  0 if (jj_scan_token(GT)) return true;
7663  0 if (jj_scan_token(GT)) return true;
7664  0 return false;
7665    }
7666   
 
7667  174 toggle private boolean jj_3R_219() {
7668  174 if (jj_scan_token(EXTENDS)) return true;
7669  0 if (jj_3R_187()) return true;
7670  12 Token xsp;
7671  12 while (true) {
7672  12 xsp = jj_scanpos;
7673  12 if (jj_3R_235()) { jj_scanpos = xsp; break; }
7674    }
7675  12 return false;
7676    }
7677   
 
7678  107112 toggle private boolean jj_3R_170() {
7679  107131 Token xsp;
7680  107143 xsp = jj_scanpos;
7681  107148 if (jj_scan_token(28)) {
7682  107135 jj_scanpos = xsp;
7683  107148 if (jj_scan_token(12)) return true;
7684    }
7685  0 return false;
7686    }
7687   
 
7688  174 toggle private boolean jj_3R_173() {
7689  0 if (jj_scan_token(IDENTIFIER)) return true;
7690  174 Token xsp;
7691  174 xsp = jj_scanpos;
7692  174 if (jj_3R_209()) jj_scanpos = xsp;
7693  174 return false;
7694    }
7695   
 
7696  107115 toggle private boolean jj_3R_105() {
7697  107140 Token xsp;
7698  107145 xsp = jj_scanpos;
7699  107139 if (jj_3R_170()) jj_scanpos = xsp;
7700  107135 if (jj_scan_token(CLASS)) return true;
7701  513 return false;
7702    }
7703   
 
7704  18 toggle private boolean jj_3R_176() {
7705  0 if (jj_scan_token(IDENTIFIER)) return true;
7706  0 if (jj_3R_92()) return true;
7707  0 Token xsp;
7708  0 xsp = jj_scanpos;
7709  0 if (jj_3R_360()) jj_scanpos = xsp;
7710  0 if (jj_scan_token(SEMICOLON)) return true;
7711  0 return false;
7712    }
7713   
 
7714  44639 toggle private boolean jj_3R_113() {
7715  44630 if (jj_scan_token(LT)) return true;
7716  0 if (jj_3R_173()) return true;
7717  165 Token xsp;
7718  165 while (true) {
7719  174 xsp = jj_scanpos;
7720  174 if (jj_3R_174()) { jj_scanpos = xsp; break; }
7721    }
7722  0 if (jj_scan_token(GT)) return true;
7723  165 return false;
7724    }
7725   
 
7726  9 toggle private boolean jj_3R_387() {
7727  9 if (jj_scan_token(FINALLY)) return true;
7728  0 if (jj_3R_190()) return true;
7729  0 return false;
7730    }
7731   
 
7732  0 toggle private boolean jj_3R_336() {
7733  0 if (jj_3R_275()) return true;
7734  0 return false;
7735    }
7736   
 
7737  6 toggle private boolean jj_3R_204() {
7738  6 if (jj_3R_104()) return true;
7739  0 return false;
7740    }
7741   
 
7742  180 toggle private boolean jj_3R_69() {
7743  0 if (jj_scan_token(IDENTIFIER)) return true;
7744  0 Token xsp;
7745  0 xsp = jj_scanpos;
7746  0 if (jj_3R_348()) jj_scanpos = xsp;
7747  0 xsp = jj_scanpos;
7748  0 if (jj_3R_349()) jj_scanpos = xsp;
7749  0 return false;
7750    }
7751   
 
7752  0 toggle private boolean jj_3R_322() {
7753  0 if (jj_scan_token(SEMICOLON)) return true;
7754  0 Token xsp;
7755  0 while (true) {
7756  0 xsp = jj_scanpos;
7757  0 if (jj_3R_336()) { jj_scanpos = xsp; break; }
7758    }
7759  0 return false;
7760    }
7761   
 
7762  15 toggle private boolean jj_3_49() {
7763  15 if (jj_scan_token(SEMICOLON)) return true;
7764  3 if (jj_3R_99()) return true;
7765  0 return false;
7766    }
7767   
 
7768  0 toggle private boolean jj_3R_335() {
7769  0 if (jj_3R_104()) return true;
7770  0 return false;
7771    }
7772   
 
7773  18 toggle private boolean jj_3R_386() {
7774  18 if (jj_scan_token(CATCH)) return true;
7775  0 if (jj_scan_token(LPAREN)) return true;
7776  0 if (jj_3R_337()) return true;
7777  0 if (jj_scan_token(RPAREN)) return true;
7778  0 if (jj_3R_190()) return true;
7779  9 return false;
7780    }
7781   
 
7782  0 toggle private boolean jj_3R_321() {
7783  0 Token xsp;
7784  0 while (true) {
7785  0 xsp = jj_scanpos;
7786  0 if (jj_3R_335()) { jj_scanpos = xsp; break; }
7787    }
7788  0 if (jj_3R_69()) return true;
7789  0 while (true) {
7790  0 xsp = jj_scanpos;
7791  0 if (jj_3_3()) { jj_scanpos = xsp; break; }
7792    }
7793  0 return false;
7794    }
7795   
 
7796  6 toggle private boolean jj_3R_163() {
7797  6 Token xsp;
7798  6 xsp = jj_scanpos;
7799  6 if (jj_scan_token(28)) {
7800  6 jj_scanpos = xsp;
7801  6 if (jj_3R_204()) return true;
7802    }
7803  0 return false;
7804    }
7805   
 
7806  14225 toggle private boolean jj_3R_112() {
7807  14211 if (jj_scan_token(LBRACE)) return true;
7808  0 Token xsp;
7809  0 xsp = jj_scanpos;
7810  0 if (jj_3R_321()) jj_scanpos = xsp;
7811  0 xsp = jj_scanpos;
7812  0 if (jj_scan_token(83)) jj_scanpos = xsp;
7813  0 xsp = jj_scanpos;
7814  0 if (jj_3R_322()) jj_scanpos = xsp;
7815  0 if (jj_scan_token(RBRACE)) return true;
7816  0 return false;
7817    }
7818   
 
7819  6 toggle private boolean jj_3R_99() {
7820  6 Token xsp;
7821  6 while (true) {
7822  6 xsp = jj_scanpos;
7823  6 if (jj_3R_163()) { jj_scanpos = xsp; break; }
7824    }
7825  3 if (jj_3R_73()) return true;
7826  0 if (jj_3R_325()) return true;
7827  0 if (jj_scan_token(ASSIGN)) return true;
7828  0 if (jj_3R_92()) return true;
7829  0 return false;
7830    }
7831   
 
7832  14225 toggle private boolean jj_3R_111() {
7833  14228 if (jj_3R_172()) return true;
7834  0 return false;
7835    }
7836   
 
7837  0 toggle private boolean jj_3R_394() {
7838  0 if (jj_3R_99()) return true;
7839  0 Token xsp;
7840  0 while (true) {
7841  0 xsp = jj_scanpos;
7842  0 if (jj_3_49()) { jj_scanpos = xsp; break; }
7843    }
7844  0 return false;
7845    }
7846   
 
7847  12 toggle private boolean jj_3_48() {
7848  12 if (jj_scan_token(SEMICOLON)) return true;
7849  3 return false;
7850    }
7851   
 
7852  43937 toggle private boolean jj_3R_71() {
7853  43949 if (jj_scan_token(IDENTIFIER)) return true;
7854  20270 if (jj_scan_token(IDENTIFIER)) return true;
7855  14229 Token xsp;
7856  14229 xsp = jj_scanpos;
7857  14229 if (jj_3R_111()) jj_scanpos = xsp;
7858  14210 if (jj_3R_112()) return true;
7859  0 return false;
7860    }
7861   
 
7862  9 toggle private boolean jj_3R_385() {
7863  9 if (jj_scan_token(LPAREN)) return true;
7864  0 if (jj_3R_394()) return true;
7865  0 Token xsp;
7866  0 xsp = jj_scanpos;
7867  0 if (jj_3_48()) jj_scanpos = xsp;
7868  0 if (jj_scan_token(RPAREN)) return true;
7869  0 return false;
7870    }
7871   
 
7872  9 toggle private boolean jj_3R_376() {
7873  9 if (jj_3R_385()) return true;
7874  0 return false;
7875    }
7876   
 
7877  0 toggle private boolean jj_3R_334() {
7878  0 if (jj_scan_token(COMMA)) return true;
7879  0 if (jj_3R_187()) return true;
7880  0 return false;
7881    }
7882   
 
7883  9 toggle private boolean jj_3R_378() {
7884  9 if (jj_3R_387()) return true;
7885  0 return false;
7886    }
7887   
 
7888  18 toggle private boolean jj_3R_377() {
7889  18 if (jj_3R_386()) return true;
7890  9 return false;
7891    }
7892   
 
7893  14666 toggle private boolean jj_3R_172() {
7894  14574 if (jj_scan_token(IMPLEMENTS)) return true;
7895  0 if (jj_3R_187()) return true;
7896  0 Token xsp;
7897  0 while (true) {
7898  0 xsp = jj_scanpos;
7899  0 if (jj_3R_334()) { jj_scanpos = xsp; break; }
7900    }
7901  0 return false;
7902    }
7903   
 
7904  66463 toggle private boolean jj_3R_203() {
7905  62675 if (jj_scan_token(TRY)) return true;
7906  9 Token xsp;
7907  9 xsp = jj_scanpos;
7908  9 if (jj_3R_376()) jj_scanpos = xsp;
7909  0 if (jj_3R_190()) return true;
7910  9 while (true) {
7911  18 xsp = jj_scanpos;
7912  18 if (jj_3R_377()) { jj_scanpos = xsp; break; }
7913    }
7914  9 xsp = jj_scanpos;
7915  9 if (jj_3R_378()) jj_scanpos = xsp;
7916  9 return false;
7917    }
7918   
 
7919  0 toggle private boolean jj_3R_333() {
7920  0 if (jj_scan_token(COMMA)) return true;
7921  0 if (jj_3R_187()) return true;
7922  0 return false;
7923    }
7924   
 
7925  549 toggle private boolean jj_3R_171() {
7926  441 if (jj_scan_token(EXTENDS)) return true;
7927  0 if (jj_3R_187()) return true;
7928  0 Token xsp;
7929  0 while (true) {
7930  0 xsp = jj_scanpos;
7931  0 if (jj_3R_333()) { jj_scanpos = xsp; break; }
7932    }
7933  0 return false;
7934    }
7935   
 
7936  66568 toggle private boolean jj_3R_202() {
7937  66500 if (jj_scan_token(SYNCHRONIZED)) return true;
7938  0 if (jj_scan_token(LPAREN)) return true;
7939  0 if (jj_3R_92()) return true;
7940  0 if (jj_scan_token(RPAREN)) return true;
7941  0 if (jj_3R_190()) return true;
7942  0 return false;
7943    }
7944   
 
7945  18 toggle private boolean jj_3R_375() {
7946  18 if (jj_3R_92()) return true;
7947  15 return false;
7948    }
7949   
 
7950  441 toggle private boolean jj_3R_109() {
7951  345 if (jj_3R_172()) return true;
7952  0 return false;
7953    }
7954   
 
7955  549 toggle private boolean jj_3R_108() {
7956  441 if (jj_3R_171()) return true;
7957  0 return false;
7958    }
7959   
 
7960  561 toggle private boolean jj_3R_107() {
7961  549 if (jj_3R_113()) return true;
7962  0 return false;
7963    }
7964   
 
7965  0 toggle private boolean jj_3R_374() {
7966  0 if (jj_scan_token(IDENTIFIER)) return true;
7967  0 return false;
7968    }
7969   
 
7970  69761 toggle private boolean jj_3R_201() {
7971  66605 if (jj_scan_token(THROW)) return true;
7972  0 if (jj_3R_92()) return true;
7973  0 if (jj_scan_token(SEMICOLON)) return true;
7974  6 return false;
7975    }
7976   
 
7977  107131 toggle private boolean jj_3R_70() {
7978  107141 Token xsp;
7979  107149 xsp = jj_scanpos;
7980  107130 if (jj_3R_105()) {
7981  106615 jj_scanpos = xsp;
7982  106616 if (jj_3R_106()) return true;
7983    }
7984  0 if (jj_scan_token(IDENTIFIER)) return true;
7985  561 xsp = jj_scanpos;
7986  549 if (jj_3R_107()) jj_scanpos = xsp;
7987  549 xsp = jj_scanpos;
7988  441 if (jj_3R_108()) jj_scanpos = xsp;
7989  441 xsp = jj_scanpos;
7990  345 if (jj_3R_109()) jj_scanpos = xsp;
7991  0 if (jj_3R_110()) return true;
7992  0 return false;
7993    }
7994   
 
7995  0 toggle private boolean jj_3R_400() {
7996  0 if (jj_scan_token(COMMA)) return true;
7997  0 if (jj_3R_192()) return true;
7998  0 return false;
7999    }
8000   
 
8001  106912 toggle private boolean jj_3R_200() {
8002  69809 if (jj_scan_token(RETURN)) return true;
8003  18 Token xsp;
8004  18 xsp = jj_scanpos;
8005  18 if (jj_3R_375()) jj_scanpos = xsp;
8006  0 if (jj_scan_token(SEMICOLON)) return true;
8007  18 return false;
8008    }
8009   
 
8010  0 toggle private boolean jj_3R_373() {
8011  0 if (jj_scan_token(IDENTIFIER)) return true;
8012  0 return false;
8013    }
8014   
 
8015  108209 toggle private boolean jj_3R_199() {
8016  106970 if (jj_scan_token(CONTINUE)) return true;
8017  0 Token xsp;
8018  0 xsp = jj_scanpos;
8019  0 if (jj_3R_374()) jj_scanpos = xsp;
8020  0 if (jj_scan_token(SEMICOLON)) return true;
8021  0 return false;
8022    }
8023   
 
8024  116686 toggle private boolean jj_3R_198() {
8025  108276 if (jj_scan_token(BREAK)) return true;
8026  0 Token xsp;
8027  0 xsp = jj_scanpos;
8028  0 if (jj_3R_373()) jj_scanpos = xsp;
8029  0 if (jj_scan_token(SEMICOLON)) return true;
8030  0 return false;
8031    }
8032   
 
8033  0 toggle private boolean jj_3R_393() {
8034  0 if (jj_3R_399()) return true;
8035  0 return false;
8036    }
8037   
 
8038  1665 toggle private boolean jj_3_47() {
8039  1665 Token xsp;
8040  1665 xsp = jj_scanpos;
8041  1665 if (jj_scan_token(28)) jj_scanpos = xsp;
8042  0 if (jj_3R_73()) return true;
8043  1665 if (jj_scan_token(IDENTIFIER)) return true;
8044  1635 return false;
8045    }
8046   
 
8047  0 toggle private boolean jj_3R_399() {
8048  0 if (jj_3R_192()) return true;
8049  0 Token xsp;
8050  0 while (true) {
8051  0 xsp = jj_scanpos;
8052  0 if (jj_3R_400()) { jj_scanpos = xsp; break; }
8053    }
8054  0 return false;
8055    }
8056   
 
8057  18 toggle private boolean jj_3R_370() {
8058  18 if (jj_scan_token(ELSE)) return true;
8059  0 if (jj_3R_95()) return true;
8060  0 return false;
8061    }
8062   
 
8063  63312 toggle private boolean jj_3R_67() {
8064  58561 if (jj_3R_104()) return true;
8065  3 return false;
8066    }
8067   
 
8068  0 toggle private boolean jj_3R_398() {
8069  0 if (jj_3R_399()) return true;
8070  0 return false;
8071    }
8072   
 
8073  63318 toggle private boolean jj_3R_66() {
8074  63329 if (jj_scan_token(STRICTFP)) return true;
8075  6 return false;
8076    }
8077   
 
8078  63336 toggle private boolean jj_3R_65() {
8079  63340 if (jj_scan_token(VOLATILE)) return true;
8080  12 return false;
8081    }
8082   
 
8083  63335 toggle private boolean jj_3R_64() {
8084  63347 if (jj_scan_token(TRANSIENT)) return true;
8085  6 return false;
8086    }
8087   
 
8088  0 toggle private boolean jj_3R_397() {
8089  0 if (jj_3R_177()) return true;
8090  0 return false;
8091    }
8092   
 
8093  0 toggle private boolean jj_3R_392() {
8094  0 Token xsp;
8095  0 xsp = jj_scanpos;
8096  0 if (jj_3R_397()) {
8097  0 jj_scanpos = xsp;
8098  0 if (jj_3R_398()) return true;
8099    }
8100  0 return false;
8101    }
8102   
 
8103  63354 toggle private boolean jj_3R_63() {
8104  63366 if (jj_scan_token(NATIVE)) return true;
8105  18 return false;
8106    }
8107   
 
8108  3423 toggle private boolean jj_3_46() {
8109  0 if (jj_3R_98()) return true;
8110  3423 if (jj_3R_73()) return true;
8111  3294 if (jj_scan_token(IDENTIFIER)) return true;
8112  3264 if (jj_scan_token(COLON)) return true;
8113  1629 return false;
8114    }
8115   
 
8116  63395 toggle private boolean jj_3R_62() {
8117  63399 if (jj_scan_token(SYNCHRONIZED)) return true;
8118  36 return false;
8119    }
8120   
 
8121  63825 toggle private boolean jj_3R_61() {
8122  63834 if (jj_scan_token(ABSTRACT)) return true;
8123  435 return false;
8124    }
8125   
 
8126  69880 toggle private boolean jj_3R_60() {
8127  69885 if (jj_scan_token(FINAL)) return true;
8128  6047 return false;
8129    }
8130   
 
8131  80606 toggle private boolean jj_3R_59() {
8132  80608 if (jj_scan_token(PRIVATE)) return true;
8133  10725 return false;
8134    }
8135   
 
8136  82047 toggle private boolean jj_3R_58() {
8137  82061 if (jj_scan_token(PROTECTED)) return true;
8138  1452 return false;
8139    }
8140   
 
8141  0 toggle private boolean jj_3R_384() {
8142  0 if (jj_3R_393()) return true;
8143  0 return false;
8144    }
8145   
 
8146  88974 toggle private boolean jj_3R_57() {
8147  88981 if (jj_scan_token(STATIC)) return true;
8148  6921 return false;
8149    }
8150   
 
8151  0 toggle private boolean jj_3R_383() {
8152  0 if (jj_3R_92()) return true;
8153  0 return false;
8154    }
8155   
 
8156  0 toggle private boolean jj_3R_382() {
8157  0 if (jj_3R_392()) return true;
8158  0 return false;
8159    }
8160   
 
8161  121204 toggle private boolean jj_3R_56() {
8162  121216 if (jj_scan_token(PUBLIC)) return true;
8163  32238 return false;
8164    }
8165   
 
8166  0 toggle private boolean jj_3R_372() {
8167  0 Token xsp;
8168  0 xsp = jj_scanpos;
8169  0 if (jj_3R_382()) jj_scanpos = xsp;
8170  0 if (jj_scan_token(SEMICOLON)) return true;
8171  0 xsp = jj_scanpos;
8172  0 if (jj_3R_383()) jj_scanpos = xsp;
8173  0 if (jj_scan_token(SEMICOLON)) return true;
8174  0 xsp = jj_scanpos;
8175  0 if (jj_3R_384()) jj_scanpos = xsp;
8176  0 return false;
8177    }
8178   
 
8179  0 toggle private boolean jj_3R_371() {
8180  0 if (jj_3R_98()) return true;
8181  0 if (jj_3R_73()) return true;
8182  0 if (jj_scan_token(IDENTIFIER)) return true;
8183  0 if (jj_scan_token(COLON)) return true;
8184  0 if (jj_3R_92()) return true;
8185  0 return false;
8186    }
8187   
 
8188  121200 toggle private boolean jj_3_2() {
8189  121217 Token xsp;
8190  121222 xsp = jj_scanpos;
8191  121214 if (jj_3R_56()) {
8192  88978 jj_scanpos = xsp;
8193  88979 if (jj_3R_57()) {
8194  82060 jj_scanpos = xsp;
8195  82057 if (jj_3R_58()) {
8196  80602 jj_scanpos = xsp;
8197  80610 if (jj_3R_59()) {
8198  69885 jj_scanpos = xsp;
8199  69880 if (jj_3R_60()) {
8200  63837 jj_scanpos = xsp;
8201  63833 if (jj_3R_61()) {
8202  63400 jj_scanpos = xsp;
8203  63401 if (jj_3R_62()) {
8204  63362 jj_scanpos = xsp;
8205  63366 if (jj_3R_63()) {
8206  63348 jj_scanpos = xsp;
8207  63346 if (jj_3R_64()) {
8208  63340 jj_scanpos = xsp;
8209  63340 if (jj_3R_65()) {
8210  63327 jj_scanpos = xsp;
8211  63329 if (jj_3R_66()) {
8212  63321 jj_scanpos = xsp;
8213  58561 if (jj_3R_67()) return true;
8214    }
8215    }
8216    }
8217    }
8218    }
8219    }
8220    }
8221    }
8222    }
8223    }
8224    }
8225  57889 return false;
8226    }
8227   
 
8228  3585 toggle private boolean jj_3R_98() {
8229  3585 Token xsp;
8230  3585 while (true) {
8231  3675 xsp = jj_scanpos;
8232  3675 if (jj_3_2()) { jj_scanpos = xsp; break; }
8233    }
8234  3585 return false;
8235    }
8236   
 
8237  123492 toggle private boolean jj_3R_197() {
8238  116755 if (jj_scan_token(FOR)) return true;
8239  0 if (jj_scan_token(LPAREN)) return true;
8240  0 Token xsp;
8241  0 xsp = jj_scanpos;
8242  0 if (jj_3R_371()) {
8243  0 jj_scanpos = xsp;
8244  0 if (jj_3R_372()) return true;
8245    }
8246  0 if (jj_scan_token(RPAREN)) return true;
8247  0 if (jj_3R_95()) return true;
8248  0 return false;
8249    }
8250   
 
8251  124191 toggle private boolean jj_3R_196() {
8252  123573 if (jj_scan_token(DO)) return true;
8253  0 if (jj_3R_95()) return true;
8254  0 if (jj_scan_token(WHILE)) return true;
8255  0 if (jj_scan_token(LPAREN)) return true;
8256  0 if (jj_3R_92()) return true;
8257  0 if (jj_scan_token(RPAREN)) return true;
8258  0 if (jj_scan_token(SEMICOLON)) return true;
8259  0 return false;
8260    }
8261   
 
8262  125853 toggle private boolean jj_3R_195() {
8263  124270 if (jj_scan_token(WHILE)) return true;
8264  0 if (jj_scan_token(LPAREN)) return true;
8265  0 if (jj_3R_92()) return true;
8266  0 if (jj_scan_token(RPAREN)) return true;
8267  0 if (jj_3R_95()) return true;
8268  0 return false;
8269    }
8270   
 
8271  9034 toggle private boolean jj_3R_55() {
8272  9035 if (jj_3R_104()) return true;
8273  87 return false;
8274    }
8275   
 
8276  8947 toggle private boolean jj_3_1() {
8277  8948 Token xsp;
8278  8948 while (true) {
8279  9035 xsp = jj_scanpos;
8280  9035 if (jj_3R_55()) { jj_scanpos = xsp; break; }
8281    }
8282  8949 if (jj_scan_token(PACKAGE)) return true;
8283  3116 return false;
8284    }
8285   
 
8286  19993 toggle private boolean jj_3_45() {
8287  8220 if (jj_3R_77()) return true;
8288  0 return false;
8289    }
8290   
 
8291  62628 toggle private boolean jj_3R_178() {
8292  62642 if (jj_3R_104()) return true;
8293  0 return false;
8294    }
8295   
 
8296  163102 toggle private boolean jj_3R_194() {
8297  125964 if (jj_scan_token(IF)) return true;
8298  0 if (jj_scan_token(LPAREN)) return true;
8299  0 if (jj_3R_92()) return true;
8300  0 if (jj_scan_token(RPAREN)) return true;
8301  0 if (jj_3R_95()) return true;
8302  18 Token xsp;
8303  18 xsp = jj_scanpos;
8304  18 if (jj_3R_370()) jj_scanpos = xsp;
8305  18 return false;
8306    }
8307   
 
8308  0 toggle private boolean jj_3R_391() {
8309  0 if (jj_scan_token(_DEFAULT)) return true;
8310  0 if (jj_scan_token(COLON)) return true;
8311  0 return false;
8312    }
8313   
 
8314  0 toggle private boolean jj_3R_390() {
8315  0 if (jj_scan_token(CASE)) return true;
8316  0 if (jj_3R_92()) return true;
8317  0 if (jj_scan_token(COLON)) return true;
8318  0 return false;
8319    }
8320   
 
8321  0 toggle private boolean jj_3R_381() {
8322  0 Token xsp;
8323  0 xsp = jj_scanpos;
8324  0 if (jj_3R_390()) {
8325  0 jj_scanpos = xsp;
8326  0 if (jj_3R_391()) return true;
8327    }
8328  0 return false;
8329    }
8330   
 
8331  179619 toggle private boolean jj_3R_221() {
8332  179636 if (jj_3R_104()) return true;
8333  0 return false;
8334    }
8335   
 
8336  0 toggle private boolean jj_3R_369() {
8337  0 if (jj_3R_381()) return true;
8338  0 Token xsp;
8339  0 while (true) {
8340  0 xsp = jj_scanpos;
8341  0 if (jj_3_45()) { jj_scanpos = xsp; break; }
8342    }
8343  0 return false;
8344    }
8345   
 
8346  48990 toggle private boolean jj_3_44() {
8347  0 if (jj_3R_78()) return true;
8348  49002 Token xsp;
8349  48999 xsp = jj_scanpos;
8350  49005 if (jj_scan_token(98)) {
8351  47234 jj_scanpos = xsp;
8352  47235 if (jj_scan_token(99)) return true;
8353    }
8354  1866 return false;
8355    }
8356   
 
8357  165469 toggle private boolean jj_3R_193() {
8358  163227 if (jj_scan_token(SWITCH)) return true;
8359  0 if (jj_scan_token(LPAREN)) return true;
8360  0 if (jj_3R_92()) return true;
8361  0 if (jj_scan_token(RPAREN)) return true;
8362  0 if (jj_scan_token(LBRACE)) return true;
8363  0 Token xsp;
8364  0 while (true) {
8365  0 xsp = jj_scanpos;
8366  0 if (jj_3R_369()) { jj_scanpos = xsp; break; }
8367    }
8368  0 if (jj_scan_token(RBRACE)) return true;
8369  0 return false;
8370    }
8371   
 
8372  0 toggle private boolean jj_3R_380() {
8373  0 if (jj_3R_239()) return true;
8374  0 if (jj_3R_92()) return true;
8375  0 return false;
8376    }
8377   
 
8378  21 toggle private boolean jj_3R_97() {
8379  21 Token xsp;
8380  21 xsp = jj_scanpos;
8381  21 if (jj_scan_token(28)) {
8382  15 jj_scanpos = xsp;
8383  15 if (jj_scan_token(12)) return true;
8384    }
8385  9 return false;
8386    }
8387   
 
8388  165530 toggle private boolean jj_3R_217() {
8389  165588 if (jj_3R_78()) return true;
8390  0 Token xsp;
8391  0 xsp = jj_scanpos;
8392  0 if (jj_3R_380()) jj_scanpos = xsp;
8393  0 return false;
8394    }
8395   
 
8396  172081 toggle private boolean jj_3R_216() {
8397  165653 if (jj_3R_233()) return true;
8398  87 return false;
8399    }
8400   
 
8401  172136 toggle private boolean jj_3R_215() {
8402  172107 if (jj_3R_232()) return true;
8403  0 return false;
8404    }
8405   
 
8406  172273 toggle private boolean jj_3R_192() {
8407  172363 Token xsp;
8408  172357 xsp = jj_scanpos;
8409  172184 if (jj_3R_214()) {
8410  172180 jj_scanpos = xsp;
8411  172103 if (jj_3R_215()) {
8412  172106 jj_scanpos = xsp;
8413  165659 if (jj_3R_216()) {
8414  165585 jj_scanpos = xsp;
8415  165574 if (jj_3R_217()) return true;
8416    }
8417    }
8418    }
8419  87 return false;
8420    }
8421   
 
8422  172321 toggle private boolean jj_3R_214() {
8423  172176 if (jj_3R_231()) return true;
8424  0 return false;
8425    }
8426   
 
8427  173158 toggle private boolean jj_3R_191() {
8428  172360 if (jj_scan_token(SEMICOLON)) return true;
8429  0 return false;
8430    }
8431   
 
8432  21 toggle private boolean jj_3R_96() {
8433  21 if (jj_3R_104()) return true;
8434  0 return false;
8435    }
8436   
 
8437  27 toggle private boolean jj_3R_361() {
8438  27 if (jj_scan_token(COMMA)) return true;
8439  0 if (jj_3R_306()) return true;
8440  0 return false;
8441    }
8442   
 
8443  21 toggle private boolean jj_3_43() {
8444  21 Token xsp;
8445  21 xsp = jj_scanpos;
8446  21 if (jj_3R_96()) jj_scanpos = xsp;
8447  21 xsp = jj_scanpos;
8448  21 if (jj_3R_97()) jj_scanpos = xsp;
8449  0 if (jj_scan_token(CLASS)) return true;
8450  21 return false;
8451    }
8452   
 
8453  117463 toggle private boolean jj_3R_147() {
8454  117509 if (jj_3R_104()) return true;
8455  18 return false;
8456    }
8457   
 
8458  180228 toggle private boolean jj_3R_210() {
8459  180270 Token xsp;
8460  180273 xsp = jj_scanpos;
8461  179669 if (jj_3R_220()) {
8462  179669 jj_scanpos = xsp;
8463  179641 if (jj_3R_221()) return true;
8464    }
8465  0 return false;
8466    }
8467   
 
8468  180266 toggle private boolean jj_3R_220() {
8469  179666 if (jj_scan_token(FINAL)) return true;
8470  0 return false;
8471    }
8472   
 
8473  180236 toggle private boolean jj_3R_177() {
8474  180276 Token xsp;
8475  180278 while (true) {
8476  180273 xsp = jj_scanpos;
8477  179646 if (jj_3R_210()) { jj_scanpos = xsp; break; }
8478    }
8479  119078 if (jj_3R_73()) return true;
8480  114 if (jj_3R_306()) return true;
8481  27 while (true) {
8482  27 xsp = jj_scanpos;
8483  27 if (jj_3R_361()) { jj_scanpos = xsp; break; }
8484    }
8485  27 return false;
8486    }
8487   
 
8488  118066 toggle private boolean jj_3R_94() {
8489  118112 Token xsp;
8490  118120 xsp = jj_scanpos;
8491  118107 if (jj_scan_token(28)) {
8492  117500 jj_scanpos = xsp;
8493  117506 if (jj_3R_147()) return true;
8494    }
8495  630 return false;
8496    }
8497   
 
8498  62627 toggle private boolean jj_3R_121() {
8499  62639 Token xsp;
8500  62642 xsp = jj_scanpos;
8501  62642 if (jj_3R_178()) jj_scanpos = xsp;
8502  62614 if (jj_3R_70()) return true;
8503  0 return false;
8504    }
8505   
 
8506  117424 toggle private boolean jj_3_41() {
8507  117485 Token xsp;
8508  117466 while (true) {
8509  118120 xsp = jj_scanpos;
8510  118116 if (jj_3R_94()) { jj_scanpos = xsp; break; }
8511    }
8512  117485 if (jj_3R_73()) return true;
8513  61196 if (jj_scan_token(IDENTIFIER)) return true;
8514  18693 return false;
8515    }
8516   
 
8517  217841 toggle private boolean jj_3_42() {
8518  62787 if (jj_3R_95()) return true;
8519  135 return false;
8520    }
8521   
 
8522  180249 toggle private boolean jj_3R_120() {
8523  119077 if (jj_3R_177()) return true;
8524  0 if (jj_scan_token(SEMICOLON)) return true;
8525  27 return false;
8526    }
8527   
 
8528  18 toggle private boolean jj_3R_119() {
8529  0 if (jj_3R_176()) return true;
8530  0 return false;
8531    }
8532   
 
8533  180284 toggle private boolean jj_3R_77() {
8534  180294 Token xsp;
8535  180305 xsp = jj_scanpos;
8536  180301 jj_lookingAhead = true;
8537  180290 jj_semLA = isNextTokenAnAssert();
8538  180294 jj_lookingAhead = false;
8539  180283 if (!jj_semLA || jj_3R_119()) {
8540  180276 jj_scanpos = xsp;
8541  119081 if (jj_3R_120()) {
8542  119049 jj_scanpos = xsp;
8543  62766 if (jj_3_42()) {
8544  62637 jj_scanpos = xsp;
8545  62618 if (jj_3R_121()) return true;
8546    }
8547    }
8548    }
8549  162 return false;
8550    }
8551   
 
8552  153894 toggle private boolean jj_3_40() {
8553  51490 if (jj_3R_77()) return true;
8554  162 return false;
8555    }
8556   
 
8557  175582 toggle private boolean jj_3R_190() {
8558  173512 if (jj_scan_token(LBRACE)) return true;
8559  117 Token xsp;
8560  117 while (true) {
8561  279 xsp = jj_scanpos;
8562  279 if (jj_3_40()) { jj_scanpos = xsp; break; }
8563    }
8564  117 if (jj_scan_token(RBRACE)) return true;
8565  114 return false;
8566    }
8567   
 
8568  471 toggle private boolean jj_3_37() {
8569  471 if (jj_scan_token(LBRACKET)) return true;
8570  0 if (jj_scan_token(RBRACKET)) return true;
8571  0 return false;
8572    }
8573   
 
8574  344767 toggle private boolean jj_3R_93() {
8575  302374 if (jj_scan_token(IDENTIFIER)) return true;
8576  44519 if (jj_scan_token(COLON)) return true;
8577  0 if (jj_3R_95()) return true;
8578  0 return false;
8579    }
8580   
 
8581  66498 toggle private boolean jj_3R_162() {
8582  62676 if (jj_3R_203()) return true;
8583  9 return false;
8584    }
8585   
 
8586  66590 toggle private boolean jj_3R_161() {
8587  66501 if (jj_3R_202()) return true;
8588  0 return false;
8589    }
8590   
 
8591  69785 toggle private boolean jj_3R_160() {
8592  66603 if (jj_3R_201()) return true;
8593  6 return false;
8594    }
8595   
 
8596  106948 toggle private boolean jj_3R_159() {
8597  69807 if (jj_3R_200()) return true;
8598  18 return false;
8599    }
8600   
 
8601  108257 toggle private boolean jj_3R_158() {
8602  106964 if (jj_3R_199()) return true;
8603  0 return false;
8604    }
8605   
 
8606  116735 toggle private boolean jj_3R_157() {
8607  108270 if (jj_3R_198()) return true;
8608  0 return false;
8609    }
8610   
 
8611  123557 toggle private boolean jj_3R_156() {
8612  116752 if (jj_3R_197()) return true;
8613  0 return false;
8614    }
8615   
 
8616  124239 toggle private boolean jj_3R_155() {
8617  123566 if (jj_3R_196()) return true;
8618  0 return false;
8619    }
8620   
 
8621  125922 toggle private boolean jj_3R_154() {
8622  124260 if (jj_3R_195()) return true;
8623  0 return false;
8624    }
8625   
 
8626  163186 toggle private boolean jj_3R_153() {
8627  125963 if (jj_3R_194()) return true;
8628  18 return false;
8629    }
8630   
 
8631  165559 toggle private boolean jj_3R_152() {
8632  163214 if (jj_3R_193()) return true;
8633  0 return false;
8634    }
8635   
 
8636  172309 toggle private boolean jj_3R_151() {
8637  165657 if (jj_3R_192()) return true;
8638  87 if (jj_scan_token(SEMICOLON)) return true;
8639  84 return false;
8640    }
8641   
 
8642  173216 toggle private boolean jj_3R_150() {
8643  172365 if (jj_3R_191()) return true;
8644  0 return false;
8645    }
8646   
 
8647  175313 toggle private boolean jj_3R_149() {
8648  173248 if (jj_3R_190()) return true;
8649  18 return false;
8650    }
8651   
 
8652  1461 toggle private boolean jj_3R_242() {
8653  1461 if (jj_3R_81()) return true;
8654  0 return false;
8655    }
8656   
 
8657  344815 toggle private boolean jj_3_39() {
8658  302136 if (jj_3R_93()) return true;
8659  0 return false;
8660    }
8661   
 
8662  217800 toggle private boolean jj_3R_95() {
8663  217846 Token xsp;
8664  217869 xsp = jj_scanpos;
8665  217833 jj_lookingAhead = true;
8666  217855 jj_semLA = isNextTokenAnAssert();
8667  217853 jj_lookingAhead = false;
8668  217844 if (!jj_semLA || jj_3R_148()) {
8669  217854 jj_scanpos = xsp;
8670  175363 if (jj_3_39()) {
8671  175365 jj_scanpos = xsp;
8672  173237 if (jj_3R_149()) {
8673  173225 jj_scanpos = xsp;
8674  172351 if (jj_3R_150()) {
8675  172363 jj_scanpos = xsp;
8676  165663 if (jj_3R_151()) {
8677  165579 jj_scanpos = xsp;
8678  163208 if (jj_3R_152()) {
8679  163213 jj_scanpos = xsp;
8680  125933 if (jj_3R_153()) {
8681  125942 jj_scanpos = xsp;
8682  124266 if (jj_3R_154()) {
8683  124261 jj_scanpos = xsp;
8684  123564 if (jj_3R_155()) {
8685  123565 jj_scanpos = xsp;
8686  116752 if (jj_3R_156()) {
8687  116756 jj_scanpos = xsp;
8688  108264 if (jj_3R_157()) {
8689  108269 jj_scanpos = xsp;
8690  106965 if (jj_3R_158()) {
8691  106963 jj_scanpos = xsp;
8692  69809 if (jj_3R_159()) {
8693  69784 jj_scanpos = xsp;
8694  66602 if (jj_3R_160()) {
8695  66598 jj_scanpos = xsp;
8696  66499 if (jj_3R_161()) {
8697  66502 jj_scanpos = xsp;
8698  62674 if (jj_3R_162()) return true;
8699    }
8700    }
8701    }
8702    }
8703    }
8704    }
8705    }
8706    }
8707    }
8708    }
8709    }
8710    }
8711    }
8712    }
8713    }
8714  153 return false;
8715    }
8716   
 
8717  0 toggle private boolean jj_3R_148() {
8718  0 if (jj_3R_176()) return true;
8719  0 return false;
8720    }
8721   
 
8722  1371 toggle private boolean jj_3R_263() {
8723  1371 if (jj_3R_110()) return true;
8724  75 return false;
8725    }
8726   
 
8727  1533 toggle private boolean jj_3R_267() {
8728  1533 if (jj_scan_token(LBRACKET)) return true;
8729  0 if (jj_scan_token(RBRACKET)) return true;
8730  81 return false;
8731    }
8732   
 
8733  3057 toggle private boolean jj_3_36() {
8734  3057 if (jj_scan_token(LBRACKET)) return true;
8735  792 if (jj_3R_92()) return true;
8736  0 if (jj_scan_token(RBRACKET)) return true;
8737  15 return false;
8738    }
8739   
 
8740  1452 toggle private boolean jj_3R_262() {
8741  1452 Token xsp;
8742  1452 if (jj_3R_267()) return true;
8743  81 while (true) {
8744  81 xsp = jj_scanpos;
8745  81 if (jj_3R_267()) { jj_scanpos = xsp; break; }
8746    }
8747  0 if (jj_3R_175()) return true;
8748  81 return false;
8749    }
8750   
 
8751  2595 toggle private boolean jj_3_38() {
8752  2595 Token xsp;
8753  2151 if (jj_3_36()) return true;
8754  15 while (true) {
8755  15 xsp = jj_scanpos;
8756  15 if (jj_3_36()) { jj_scanpos = xsp; break; }
8757    }
8758  15 while (true) {
8759  15 xsp = jj_scanpos;
8760  15 if (jj_3_37()) { jj_scanpos = xsp; break; }
8761    }
8762  15 return false;
8763    }
8764   
 
8765  1467 toggle private boolean jj_3R_241() {
8766  1467 Token xsp;
8767  1467 xsp = jj_scanpos;
8768  1467 if (jj_3_38()) {
8769  1452 jj_scanpos = xsp;
8770  1452 if (jj_3R_262()) return true;
8771    }
8772  96 return false;
8773    }
8774   
 
8775  1371 toggle private boolean jj_3R_244() {
8776  0 if (jj_3R_79()) return true;
8777  1371 Token xsp;
8778  1371 xsp = jj_scanpos;
8779  1371 if (jj_3R_263()) jj_scanpos = xsp;
8780  1371 return false;
8781    }
8782   
 
8783  53350 toggle private boolean jj_3R_212() {
8784  53365 if (jj_scan_token(COMMA)) return true;
8785  0 if (jj_3R_92()) return true;
8786  18457 return false;
8787    }
8788   
 
8789  1461 toggle private boolean jj_3R_243() {
8790  1461 if (jj_3R_241()) return true;
8791  90 return false;
8792    }
8793   
 
8794  532469 toggle private boolean jj_3R_145() {
8795  532782 if (jj_scan_token(NEW)) return true;
8796  0 if (jj_3R_187()) return true;
8797  1461 Token xsp;
8798  1461 xsp = jj_scanpos;
8799  1461 if (jj_3R_242()) jj_scanpos = xsp;
8800  1461 xsp = jj_scanpos;
8801  1461 if (jj_3R_243()) {
8802  1371 jj_scanpos = xsp;
8803  0 if (jj_3R_244()) return true;
8804    }
8805  1461 return false;
8806    }
8807   
 
8808  533938 toggle private boolean jj_3R_90() {
8809  534200 Token xsp;
8810  534181 xsp = jj_scanpos;
8811  532765 if (jj_3_35()) {
8812  532712 jj_scanpos = xsp;
8813  532761 if (jj_3R_145()) return true;
8814    }
8815  1467 return false;
8816    }
8817   
 
8818  547475 toggle private boolean jj_3_35() {
8819  546310 if (jj_scan_token(NEW)) return true;
8820  14781 if (jj_3R_87()) return true;
8821  0 if (jj_3R_241()) return true;
8822  6 return false;
8823    }
8824   
 
8825  133570 toggle private boolean jj_3R_123() {
8826  80422 if (jj_3R_186()) return true;
8827  34907 return false;
8828    }
8829   
 
8830  133588 toggle private boolean jj_3R_186() {
8831  80420 if (jj_3R_92()) return true;
8832  34905 Token xsp;
8833  34906 while (true) {
8834  53362 xsp = jj_scanpos;
8835  53354 if (jj_3R_212()) { jj_scanpos = xsp; break; }
8836    }
8837  34908 return false;
8838    }
8839   
 
8840  549216 toggle private boolean jj_3R_79() {
8841  549614 if (jj_scan_token(LPAREN)) return true;
8842  133592 Token xsp;
8843  133604 xsp = jj_scanpos;
8844  80425 if (jj_3R_123()) jj_scanpos = xsp;
8845  47663 if (jj_scan_token(RPAREN)) return true;
8846  47662 return false;
8847    }
8848   
 
8849  30 toggle private boolean jj_3R_188() {
8850  30 if (jj_3R_211()) return true;
8851  27 return false;
8852    }
8853   
 
8854  514029 toggle private boolean jj_3R_237() {
8855  513737 if (jj_scan_token(NULL)) return true;
8856  444 return false;
8857    }
8858   
 
8859  516118 toggle private boolean jj_3R_236() {
8860  516250 Token xsp;
8861  516249 xsp = jj_scanpos;
8862  515977 if (jj_3R_247()) {
8863  514776 jj_scanpos = xsp;
8864  514642 if (jj_scan_token(27)) return true;
8865    }
8866  1527 return false;
8867    }
8868   
 
8869  516114 toggle private boolean jj_3R_247() {
8870  515980 if (jj_scan_token(TRUE)) return true;
8871  1137 return false;
8872    }
8873   
 
8874  514031 toggle private boolean jj_3R_228() {
8875  513731 if (jj_3R_237()) return true;
8876  444 return false;
8877    }
8878   
 
8879  58733 toggle private boolean jj_3R_396() {
8880  58740 if (jj_scan_token(DECR)) return true;
8881  0 return false;
8882    }
8883   
 
8884  516293 toggle private boolean jj_3R_227() {
8885  515766 if (jj_3R_236()) return true;
8886  1527 return false;
8887    }
8888   
 
8889  540575 toggle private boolean jj_3R_226() {
8890  527696 if (jj_scan_token(STRING_LITERAL)) return true;
8891  11325 return false;
8892    }
8893   
 
8894  541656 toggle private boolean jj_3R_225() {
8895  541105 if (jj_scan_token(CHARACTER_LITERAL)) return true;
8896  432 return false;
8897    }
8898   
 
8899  541735 toggle private boolean jj_3R_224() {
8900  541776 if (jj_scan_token(HEX_FLOATING_POINT_LITERAL)) return true;
8901  0 return false;
8902    }
8903   
 
8904  541929 toggle private boolean jj_3R_223() {
8905  541995 if (jj_scan_token(FLOATING_POINT_LITERAL)) return true;
8906  210 return false;
8907    }
8908   
 
8909  559567 toggle private boolean jj_3R_211() {
8910  559890 Token xsp;
8911  559899 xsp = jj_scanpos;
8912  548375 if (jj_3R_222()) {
8913  541975 jj_scanpos = xsp;
8914  541985 if (jj_3R_223()) {
8915  541762 jj_scanpos = xsp;
8916  541767 if (jj_3R_224()) {
8917  541712 jj_scanpos = xsp;
8918  541043 if (jj_3R_225()) {
8919  540648 jj_scanpos = xsp;
8920  527701 if (jj_3R_226()) {
8921  516379 jj_scanpos = xsp;
8922  515763 if (jj_3R_227()) {
8923  514234 jj_scanpos = xsp;
8924  513725 if (jj_3R_228()) return true;
8925    }
8926    }
8927    }
8928    }
8929    }
8930    }
8931  20244 return false;
8932    }
8933   
 
8934  559651 toggle private boolean jj_3R_222() {
8935  548377 if (jj_scan_token(INTEGER_LITERAL)) return true;
8936  6306 return false;
8937    }
8938   
 
8939  545353 toggle private boolean jj_3R_143() {
8940  459477 if (jj_3R_79()) return true;
8941  44303 return false;
8942    }
8943   
 
8944  564503 toggle private boolean jj_3R_142() {
8945  564825 if (jj_scan_token(DOT)) return true;
8946  0 if (jj_scan_token(IDENTIFIER)) return true;
8947  6675 return false;
8948    }
8949   
 
8950  183688 toggle private boolean jj_3_30() {
8951  0 if (jj_3R_89()) return true;
8952  183770 if (jj_scan_token(DOT)) return true;
8953  3819 if (jj_scan_token(CLASS)) return true;
8954  3780 return false;
8955    }
8956   
 
8957  569450 toggle private boolean jj_3R_141() {
8958  569630 if (jj_scan_token(LBRACKET)) return true;
8959  0 if (jj_3R_92()) return true;
8960  0 if (jj_scan_token(RBRACKET)) return true;
8961  1697 return false;
8962    }
8963   
 
8964  671199 toggle private boolean jj_3_34() {
8965  671388 if (jj_3R_91()) return true;
8966  0 return false;
8967    }
8968   
 
8969  59292 toggle private boolean jj_3R_356() {
8970  59293 if (jj_scan_token(REM)) return true;
8971  0 return false;
8972    }
8973   
 
8974  671129 toggle private boolean jj_3_33() {
8975  671439 if (jj_scan_token(DOT)) return true;
8976  32169 if (jj_3R_90()) return true;
8977  0 return false;
8978    }
8979   
 
8980  569375 toggle private boolean jj_3R_88() {
8981  569622 Token xsp;
8982  569585 xsp = jj_scanpos;
8983  569621 if (jj_3_31()) {
8984  569587 jj_scanpos = xsp;
8985  569502 if (jj_3_32()) {
8986  569551 jj_scanpos = xsp;
8987  569624 if (jj_3_33()) {
8988  569581 jj_scanpos = xsp;
8989  569545 if (jj_3_34()) {
8990  569559 jj_scanpos = xsp;
8991  566467 if (jj_3R_141()) {
8992  564818 jj_scanpos = xsp;
8993  552088 if (jj_3R_142()) {
8994  545422 jj_scanpos = xsp;
8995  459471 if (jj_3R_143()) return true;
8996    }
8997    }
8998    }
8999    }
9000    }
9001    }
9002  52690 return false;
9003    }
9004   
 
9005  671179 toggle private boolean jj_3_32() {
9006  671451 if (jj_scan_token(DOT)) return true;
9007  32169 if (jj_scan_token(SUPER)) return true;
9008  0 return false;
9009    }
9010   
 
9011  671159 toggle private boolean jj_3_31() {
9012  671440 if (jj_scan_token(DOT)) return true;
9013  32184 if (jj_scan_token(THIS)) return true;
9014  15 return false;
9015    }
9016   
 
9017  463486 toggle private boolean jj_3R_185() {
9018  463632 if (jj_3R_100()) return true;
9019  82487 return false;
9020    }
9021   
 
9022  498786 toggle private boolean jj_3R_184() {
9023  464501 if (jj_3R_89()) return true;
9024  83463 if (jj_scan_token(DOT)) return true;
9025  942 if (jj_scan_token(CLASS)) return true;
9026  927 return false;
9027    }
9028   
 
9029  569457 toggle private boolean jj_3_29() {
9030  467826 if (jj_3R_88()) return true;
9031  52686 return false;
9032    }
9033   
 
9034  501950 toggle private boolean jj_3R_183() {
9035  500553 if (jj_3R_90()) return true;
9036  1467 return false;
9037    }
9038   
 
9039  502588 toggle private boolean jj_3R_182() {
9040  502550 if (jj_scan_token(LPAREN)) return true;
9041  0 if (jj_3R_92()) return true;
9042  0 if (jj_scan_token(RPAREN)) return true;
9043  495 return false;
9044    }
9045   
 
9046  504356 toggle private boolean jj_3R_181() {
9047  503282 if (jj_scan_token(SUPER)) return true;
9048  3639 if (jj_scan_token(DOT)) return true;
9049  0 if (jj_scan_token(IDENTIFIER)) return true;
9050  609 return false;
9051    }
9052   
 
9053  513199 toggle private boolean jj_3R_180() {
9054  507631 if (jj_scan_token(THIS)) return true;
9055  3117 return false;
9056    }
9057   
 
9058  559632 toggle private boolean jj_3R_122() {
9059  559791 Token xsp;
9060  559760 xsp = jj_scanpos;
9061  533412 if (jj_3R_179()) {
9062  513193 jj_scanpos = xsp;
9063  507524 if (jj_3R_180()) {
9064  504456 jj_scanpos = xsp;
9065  503218 if (jj_3R_181()) {
9066  502613 jj_scanpos = xsp;
9067  502553 if (jj_3R_182()) {
9068  502036 jj_scanpos = xsp;
9069  500545 if (jj_3R_183()) {
9070  499109 jj_scanpos = xsp;
9071  464558 if (jj_3R_184()) {
9072  463610 jj_scanpos = xsp;
9073  463629 if (jj_3R_185()) return true;
9074    }
9075    }
9076    }
9077    }
9078    }
9079    }
9080  109319 return false;
9081    }
9082   
 
9083  559618 toggle private boolean jj_3R_179() {
9084  533350 if (jj_3R_211()) return true;
9085  20217 return false;
9086    }
9087   
 
9088  59461 toggle private boolean jj_3R_395() {
9089  59461 if (jj_scan_token(INCR)) return true;
9090  723 return false;
9091    }
9092   
 
9093  59455 toggle private boolean jj_3R_389() {
9094  59462 Token xsp;
9095  59463 xsp = jj_scanpos;
9096  59456 if (jj_3R_395()) {
9097  58737 jj_scanpos = xsp;
9098  58740 if (jj_3R_396()) return true;
9099    }
9100  723 return false;
9101    }
9102   
 
9103  671073 toggle private boolean jj_3R_91() {
9104  671440 if (jj_scan_token(DOT)) return true;
9105  32114 if (jj_3R_81()) return true;
9106  0 if (jj_scan_token(IDENTIFIER)) return true;
9107  0 return false;
9108    }
9109   
 
9110  7998 toggle private boolean jj_3_28() {
9111  0 if (jj_scan_token(LPAREN)) return true;
9112  7998 if (jj_3R_87()) return true;
9113  2736 return false;
9114    }
9115   
 
9116  171086 toggle private boolean jj_3R_358() {
9117  171092 if (jj_scan_token(BANG)) return true;
9118  39 return false;
9119    }
9120   
 
9121  559660 toggle private boolean jj_3R_78() {
9122  490390 if (jj_3R_122()) return true;
9123  109316 Token xsp;
9124  109307 while (true) {
9125  162011 xsp = jj_scanpos;
9126  161983 if (jj_3_29()) { jj_scanpos = xsp; break; }
9127    }
9128  109306 return false;
9129    }
9130   
 
9131  56688 toggle private boolean jj_3R_344() {
9132  56694 if (jj_scan_token(MINUS)) return true;
9133  330 return false;
9134    }
9135   
 
9136  59347 toggle private boolean jj_3R_355() {
9137  59352 if (jj_scan_token(SLASH)) return true;
9138  57 return false;
9139    }
9140   
 
9141  168778 toggle private boolean jj_3R_368() {
9142  168822 if (jj_scan_token(LPAREN)) return true;
9143  408 if (jj_3R_73()) return true;
9144  150 if (jj_scan_token(RPAREN)) return true;
9145  0 if (jj_3R_332()) return true;
9146  0 return false;
9147    }
9148   
 
9149  171008 toggle private boolean jj_3R_359() {
9150  171043 Token xsp;
9151  171057 xsp = jj_scanpos;
9152  169458 if (jj_3R_367()) {
9153  168823 jj_scanpos = xsp;
9154  168823 if (jj_3R_368()) return true;
9155    }
9156  633 return false;
9157    }
9158   
 
9159  171014 toggle private boolean jj_3R_367() {
9160  169461 if (jj_scan_token(LPAREN)) return true;
9161  1041 if (jj_3R_73()) return true;
9162  783 if (jj_scan_token(RPAREN)) return true;
9163  0 if (jj_3R_301()) return true;
9164  633 return false;
9165    }
9166   
 
9167  0 toggle private boolean jj_3_27() {
9168  0 if (jj_scan_token(LPAREN)) return true;
9169  0 if (jj_3R_73()) return true;
9170  0 if (jj_scan_token(LBRACKET)) return true;
9171  0 return false;
9172    }
9173   
 
9174  340750 toggle private boolean jj_3R_233() {
9175  271443 if (jj_3R_78()) return true;
9176  59452 Token xsp;
9177  59460 xsp = jj_scanpos;
9178  59463 if (jj_3R_389()) jj_scanpos = xsp;
9179  59455 return false;
9180    }
9181   
 
9182  261512 toggle private boolean jj_3R_132() {
9183  261685 if (jj_scan_token(LPAREN)) return true;
9184  11862 if (jj_3R_73()) return true;
9185  8178 if (jj_scan_token(RPAREN)) return true;
9186  5274 Token xsp;
9187  5274 xsp = jj_scanpos;
9188  5274 if (jj_scan_token(89)) {
9189  5274 jj_scanpos = xsp;
9190  5274 if (jj_scan_token(88)) {
9191  5274 jj_scanpos = xsp;
9192  5274 if (jj_scan_token(76)) {
9193  5178 jj_scanpos = xsp;
9194  5178 if (jj_scan_token(73)) {
9195  42 jj_scanpos = xsp;
9196  42 if (jj_scan_token(53)) {
9197  30 jj_scanpos = xsp;
9198  30 if (jj_scan_token(50)) {
9199  30 jj_scanpos = xsp;
9200  30 if (jj_scan_token(41)) {
9201  30 jj_scanpos = xsp;
9202  30 if (jj_3R_188()) return true;
9203    }
9204    }
9205    }
9206    }
9207    }
9208    }
9209    }
9210  5271 return false;
9211    }
9212   
 
9213  264285 toggle private boolean jj_3_25() {
9214  264392 if (jj_3R_86()) return true;
9215  7998 return false;
9216    }
9217   
 
9218  172714 toggle private boolean jj_3R_331() {
9219  171610 if (jj_scan_token(MINUS)) return true;
9220  282 return false;
9221    }
9222   
 
9223  261548 toggle private boolean jj_3R_131() {
9224  261645 if (jj_scan_token(LPAREN)) return true;
9225  11862 if (jj_3R_73()) return true;
9226  8178 if (jj_scan_token(LBRACKET)) return true;
9227  300 if (jj_scan_token(RBRACKET)) return true;
9228  0 return false;
9229    }
9230   
 
9231  264220 toggle private boolean jj_3R_86() {
9232  264364 Token xsp;
9233  264367 xsp = jj_scanpos;
9234  264371 if (jj_3_26()) {
9235  261653 jj_scanpos = xsp;
9236  261659 if (jj_3R_131()) {
9237  261651 jj_scanpos = xsp;
9238  261635 if (jj_3R_132()) return true;
9239    }
9240    }
9241  7998 return false;
9242    }
9243   
 
9244  264232 toggle private boolean jj_3_26() {
9245  264343 if (jj_scan_token(LPAREN)) return true;
9246  14589 if (jj_3R_87()) return true;
9247  2736 if (jj_scan_token(RPAREN)) return true;
9248  2727 return false;
9249    }
9250   
 
9251  168790 toggle private boolean jj_3R_347() {
9252  105818 if (jj_3R_233()) return true;
9253  59371 return false;
9254    }
9255   
 
9256  171066 toggle private boolean jj_3R_357() {
9257  171123 if (jj_scan_token(TILDE)) return true;
9258  0 return false;
9259    }
9260   
 
9261  171043 toggle private boolean jj_3R_346() {
9262  169446 if (jj_3R_359()) return true;
9263  633 return false;
9264    }
9265   
 
9266  171067 toggle private boolean jj_3R_345() {
9267  171111 Token xsp;
9268  171116 xsp = jj_scanpos;
9269  171117 if (jj_3R_357()) {
9270  171115 jj_scanpos = xsp;
9271  171090 if (jj_3R_358()) return true;
9272    }
9273  0 if (jj_3R_301()) return true;
9274  39 return false;
9275    }
9276   
 
9277  171084 toggle private boolean jj_3R_332() {
9278  171101 Token xsp;
9279  171119 xsp = jj_scanpos;
9280  171083 if (jj_3R_345()) {
9281  171045 jj_scanpos = xsp;
9282  169457 if (jj_3R_346()) {
9283  168811 jj_scanpos = xsp;
9284  105820 if (jj_3R_347()) return true;
9285    }
9286    }
9287  60041 return false;
9288    }
9289   
 
9290  59280 toggle private boolean jj_3R_343() {
9291  59294 if (jj_scan_token(PLUS)) return true;
9292  2601 return false;
9293    }
9294   
 
9295  59278 toggle private boolean jj_3R_329() {
9296  59293 Token xsp;
9297  59289 xsp = jj_scanpos;
9298  59293 if (jj_3R_343()) {
9299  56694 jj_scanpos = xsp;
9300  56694 if (jj_3R_344()) return true;
9301    }
9302  0 if (jj_3R_294()) return true;
9303  2931 return false;
9304    }
9305   
 
9306  59381 toggle private boolean jj_3R_354() {
9307  59392 if (jj_scan_token(STAR)) return true;
9308  42 return false;
9309    }
9310   
 
9311  343334 toggle private boolean jj_3R_232() {
9312  343244 if (jj_scan_token(DECR)) return true;
9313  0 if (jj_3R_78()) return true;
9314  6 return false;
9315    }
9316   
 
9317  59382 toggle private boolean jj_3R_342() {
9318  59387 Token xsp;
9319  59391 xsp = jj_scanpos;
9320  59387 if (jj_3R_354()) {
9321  59349 jj_scanpos = xsp;
9322  59352 if (jj_3R_355()) {
9323  59293 jj_scanpos = xsp;
9324  59295 if (jj_3R_356()) return true;
9325    }
9326    }
9327  0 if (jj_3R_301()) return true;
9328  99 return false;
9329    }
9330   
 
9331  56133 toggle private boolean jj_3R_293() {
9332  56147 if (jj_scan_token(NE)) return true;
9333  36 return false;
9334    }
9335   
 
9336  343559 toggle private boolean jj_3R_231() {
9337  343513 if (jj_scan_token(INCR)) return true;
9338  0 if (jj_3R_78()) return true;
9339  12 return false;
9340    }
9341   
 
9342  171118 toggle private boolean jj_3R_320() {
9343  106490 if (jj_3R_332()) return true;
9344  60045 return false;
9345    }
9346   
 
9347  171300 toggle private boolean jj_3R_319() {
9348  171127 if (jj_3R_232()) return true;
9349  6 return false;
9350    }
9351   
 
9352  171315 toggle private boolean jj_3R_318() {
9353  171318 if (jj_3R_231()) return true;
9354  12 return false;
9355    }
9356   
 
9357  172692 toggle private boolean jj_3R_330() {
9358  172736 if (jj_scan_token(PLUS)) return true;
9359  0 return false;
9360    }
9361   
 
9362  172649 toggle private boolean jj_3R_317() {
9363  172722 Token xsp;
9364  172731 xsp = jj_scanpos;
9365  172731 if (jj_3R_330()) {
9366  172730 jj_scanpos = xsp;
9367  171608 if (jj_3R_331()) return true;
9368    }
9369  0 if (jj_3R_301()) return true;
9370  282 return false;
9371    }
9372   
 
9373  172639 toggle private boolean jj_3R_301() {
9374  172691 Token xsp;
9375  172708 xsp = jj_scanpos;
9376  171609 if (jj_3R_317()) {
9377  171329 jj_scanpos = xsp;
9378  171319 if (jj_3R_318()) {
9379  171308 jj_scanpos = xsp;
9380  171127 if (jj_3R_319()) {
9381  171116 jj_scanpos = xsp;
9382  106491 if (jj_3R_320()) return true;
9383    }
9384    }
9385    }
9386  60347 return false;
9387    }
9388   
 
9389  171617 toggle private boolean jj_3R_294() {
9390  105737 if (jj_3R_301()) return true;
9391  59287 Token xsp;
9392  59289 while (true) {
9393  59392 xsp = jj_scanpos;
9394  59392 if (jj_3R_342()) { jj_scanpos = xsp; break; }
9395    }
9396  59287 return false;
9397    }
9398   
 
9399  168658 toggle private boolean jj_3R_283() {
9400  102794 if (jj_3R_294()) return true;
9401  56354 Token xsp;
9402  56353 while (true) {
9403  59287 xsp = jj_scanpos;
9404  59292 if (jj_3R_329()) { jj_scanpos = xsp; break; }
9405    }
9406  56360 return false;
9407    }
9408   
 
9409  294938 toggle private boolean jj_3_24() {
9410  294903 if (jj_3R_85()) return true;
9411  0 return false;
9412    }
9413   
 
9414  295237 toggle private boolean jj_3_23() {
9415  294959 if (jj_3R_84()) return true;
9416  0 return false;
9417    }
9418   
 
9419  56266 toggle private boolean jj_3R_291() {
9420  56279 if (jj_scan_token(INSTANCEOF)) return true;
9421  0 if (jj_3R_73()) return true;
9422  129 return false;
9423    }
9424   
 
9425  295326 toggle private boolean jj_3R_83() {
9426  295188 if (jj_scan_token(LSHIFT)) return true;
9427  0 return false;
9428    }
9429   
 
9430  56273 toggle private boolean jj_3R_292() {
9431  56275 if (jj_scan_token(EQ)) return true;
9432  132 return false;
9433    }
9434   
 
9435  295325 toggle private boolean jj_3_22() {
9436  295499 Token xsp;
9437  295465 xsp = jj_scanpos;
9438  295174 if (jj_3R_83()) {
9439  295158 jj_scanpos = xsp;
9440  294954 if (jj_3_23()) {
9441  294962 jj_scanpos = xsp;
9442  294890 if (jj_3_24()) return true;
9443    }
9444    }
9445  0 if (jj_3R_283()) return true;
9446  0 return false;
9447    }
9448   
 
9449  56269 toggle private boolean jj_3R_282() {
9450  56276 Token xsp;
9451  56274 xsp = jj_scanpos;
9452  56276 if (jj_3R_292()) {
9453  56143 jj_scanpos = xsp;
9454  56146 if (jj_3R_293()) return true;
9455    }
9456  0 if (jj_3R_270()) return true;
9457  168 return false;
9458    }
9459   
 
9460  168675 toggle private boolean jj_3R_278() {
9461  102785 if (jj_3R_283()) return true;
9462  56356 Token xsp;
9463  56355 while (true) {
9464  56364 xsp = jj_scanpos;
9465  56357 if (jj_3_22()) { jj_scanpos = xsp; break; }
9466    }
9467  56361 return false;
9468    }
9469   
 
9470  56278 toggle private boolean jj_3R_316() {
9471  56283 if (jj_scan_token(GE)) return true;
9472  3 return false;
9473    }
9474   
 
9475  56280 toggle private boolean jj_3R_315() {
9476  56286 if (jj_scan_token(LE)) return true;
9477  3 return false;
9478    }
9479   
 
9480  56328 toggle private boolean jj_3R_314() {
9481  56337 if (jj_scan_token(GT)) return true;
9482  51 return false;
9483    }
9484   
 
9485  56348 toggle private boolean jj_3R_313() {
9486  56358 if (jj_scan_token(LT)) return true;
9487  27 return false;
9488    }
9489   
 
9490  56104 toggle private boolean jj_3R_277() {
9491  56111 if (jj_scan_token(BIT_AND)) return true;
9492  0 if (jj_3R_266()) return true;
9493  0 return false;
9494    }
9495   
 
9496  56345 toggle private boolean jj_3R_300() {
9497  56362 Token xsp;
9498  56356 xsp = jj_scanpos;
9499  56358 if (jj_3R_313()) {
9500  56333 jj_scanpos = xsp;
9501  56336 if (jj_3R_314()) {
9502  56285 jj_scanpos = xsp;
9503  56286 if (jj_3R_315()) {
9504  56282 jj_scanpos = xsp;
9505  56281 if (jj_3R_316()) return true;
9506    }
9507    }
9508    }
9509  0 if (jj_3R_278()) return true;
9510  84 return false;
9511    }
9512   
 
9513  168596 toggle private boolean jj_3R_274() {
9514  102704 if (jj_3R_278()) return true;
9515  56269 Token xsp;
9516  56274 while (true) {
9517  56360 xsp = jj_scanpos;
9518  56358 if (jj_3R_300()) { jj_scanpos = xsp; break; }
9519    }
9520  56278 return false;
9521    }
9522   
 
9523  56108 toggle private boolean jj_3R_269() {
9524  56111 if (jj_scan_token(BIT_OR)) return true;
9525  0 if (jj_3R_240()) return true;
9526  0 return false;
9527    }
9528   
 
9529  56105 toggle private boolean jj_3R_273() {
9530  56110 if (jj_scan_token(XOR)) return true;
9531  0 if (jj_3R_261()) return true;
9532  0 return false;
9533    }
9534   
 
9535  168595 toggle private boolean jj_3R_270() {
9536  102716 if (jj_3R_274()) return true;
9537  56271 Token xsp;
9538  56279 xsp = jj_scanpos;
9539  56274 if (jj_3R_291()) jj_scanpos = xsp;
9540  56277 return false;
9541    }
9542   
 
9543  56107 toggle private boolean jj_3R_265() {
9544  56112 if (jj_scan_token(SC_AND)) return true;
9545  0 if (jj_3R_230()) return true;
9546  12 return false;
9547    }
9548   
 
9549  168422 toggle private boolean jj_3R_266() {
9550  102534 if (jj_3R_270()) return true;
9551  56104 Token xsp;
9552  56097 while (true) {
9553  56273 xsp = jj_scanpos;
9554  56278 if (jj_3R_282()) { jj_scanpos = xsp; break; }
9555    }
9556  56107 return false;
9557    }
9558   
 
9559  56090 toggle private boolean jj_3R_248() {
9560  56100 if (jj_scan_token(SC_OR)) return true;
9561  0 if (jj_3R_213()) return true;
9562  6 return false;
9563    }
9564   
 
9565  168446 toggle private boolean jj_3R_261() {
9566  102552 if (jj_3R_266()) return true;
9567  56106 Token xsp;
9568  56103 while (true) {
9569  56108 xsp = jj_scanpos;
9570  56107 if (jj_3R_277()) { jj_scanpos = xsp; break; }
9571    }
9572  56105 return false;
9573    }
9574   
 
9575  56075 toggle private boolean jj_3R_238() {
9576  56092 if (jj_scan_token(HOOK)) return true;
9577  0 if (jj_3R_92()) return true;
9578  0 if (jj_scan_token(COLON)) return true;
9579  0 if (jj_3R_146()) return true;
9580  90 return false;
9581    }
9582   
 
9583  168441 toggle private boolean jj_3R_240() {
9584  102543 if (jj_3R_261()) return true;
9585  56108 Token xsp;
9586  56106 while (true) {
9587  56107 xsp = jj_scanpos;
9588  56109 if (jj_3R_273()) { jj_scanpos = xsp; break; }
9589    }
9590  56108 return false;
9591    }
9592   
 
9593  168432 toggle private boolean jj_3R_230() {
9594  102550 if (jj_3R_240()) return true;
9595  56108 Token xsp;
9596  56110 while (true) {
9597  56109 xsp = jj_scanpos;
9598  56108 if (jj_3R_269()) { jj_scanpos = xsp; break; }
9599    }
9600  56111 return false;
9601    }
9602   
 
9603  168427 toggle private boolean jj_3R_213() {
9604  102546 if (jj_3R_230()) return true;
9605  56100 Token xsp;
9606  56098 while (true) {
9607  56112 xsp = jj_scanpos;
9608  56107 if (jj_3R_265()) { jj_scanpos = xsp; break; }
9609    }
9610  56100 return false;
9611    }
9612   
 
9613  168429 toggle private boolean jj_3R_189() {
9614  102538 if (jj_3R_213()) return true;
9615  56092 Token xsp;
9616  56090 while (true) {
9617  56099 xsp = jj_scanpos;
9618  56098 if (jj_3R_248()) { jj_scanpos = xsp; break; }
9619    }
9620  56091 return false;
9621    }
9622   
 
9623  168410 toggle private boolean jj_3R_146() {
9624  102532 if (jj_3R_189()) return true;
9625  56087 Token xsp;
9626  56092 xsp = jj_scanpos;
9627  56088 if (jj_3R_238()) jj_scanpos = xsp;
9628  56089 return false;
9629    }
9630   
 
9631  55871 toggle private boolean jj_3R_260() {
9632  55882 if (jj_scan_token(ORASSIGN)) return true;
9633  0 return false;
9634    }
9635   
 
9636  55877 toggle private boolean jj_3R_259() {
9637  55882 if (jj_scan_token(XORASSIGN)) return true;
9638  0 return false;
9639    }
9640   
 
9641  55873 toggle private boolean jj_3R_258() {
9642  55884 if (jj_scan_token(ANDASSIGN)) return true;
9643  0 return false;
9644    }
9645   
9646    /** Generated Token Manager. */
9647    public JavaParserTokenManager token_source;
9648    /** Current token. */
9649    public Token token;
9650    /** Next token. */
9651    public Token jj_nt;
9652    private Token jj_scanpos, jj_lastpos;
9653    private int jj_la;
9654    /** Whether we are looking ahead. */
9655    private boolean jj_lookingAhead = false;
9656    private boolean jj_semLA;
9657    private int jj_gen;
9658    final private int[] jj_la1 = new int[142];
9659    static private int[] jj_la1_0;
9660    static private int[] jj_la1_1;
9661    static private int[] jj_la1_2;
9662    static private int[] jj_la1_3;
 
9663  3 toggle static {
9664  3 jj_la1_init_0();
9665  3 jj_la1_init_1();
9666  3 jj_la1_init_2();
9667  3 jj_la1_init_3();
9668    }
 
9669  3 toggle private static void jj_la1_init_0() {
9670  3 jj_la1_0 = new int[] {0x0,0x10081000,0x0,0x0,0x0,0x0,0x0,0x10001000,0x10081000,0x10081000,0x10001000,0x10001000,0x10081000,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x510cb000,0x0,0x0,0x0,0x0,0x4000000,0x0,0x510cb000,0x4104a000,0x510cb000,0x0,0x0,0x0,0x4904a000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x5104a000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4104a000,0x4104a000,0x0,0x0,0x4000000,0x4104a000,0x4000000,0x4104a000,0x4104a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x0,0x4904a000,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x8000000,0x8000000,0x4904a000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc9a4e000,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x4904a000,0x410000,0x410000,0x2000000,0x5904a000,0x4904a000,0x4904a000,0x5904a000,0x4904a000,0x0,0x0,0x0,0x4904a000,0x0,0x20000,0x20000000,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x4904a000,0x0,0x4904a000,0x510cb000,0x10081000,0x4104a000,0x510cb000,0x400000,};
9671    }
 
9672  3 toggle private static void jj_la1_init_1() {
9673  3 jj_la1_1 = new int[] {0x8,0x51127140,0x0,0x0,0x0,0x20000,0x0,0x51127100,0x40,0x51127140,0x0,0x0,0x40,0x0,0x0,0x4,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x591371e0,0x0,0x0,0x0,0x0,0x0,0x0,0x591371e0,0x80100a0,0x591371e0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x800000,0x0,0x0,0x0,0x100a0,0x0,0x0,0x0,0x0,0x0,0x800000,0x240000,0x8a2506a0,0x20000,0x100a0,0x100a0,0x0,0x0,0x40000,0x100a0,0x40000,0x100a0,0x80100a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x8a2506a0,0x82240600,0x0,0x0,0x0,0x0,0x82240600,0x0,0x0,0x82000400,0x2000000,0x8a2506a0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xae7d86a2,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x8a2506a0,0x0,0x0,0x0,0x8a2506a0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8a2506a0,0x0,0x8a2506a0,0x511371e0,0x40,0x100a0,0x511371e0,0x0,};
9674    }
 
9675  3 toggle private static void jj_la1_init_2() {
9676  3 jj_la1_2 = new int[] {0x0,0x240200,0x0,0x0,0x200000,0x0,0x100000,0x200000,0x200200,0x240200,0x0,0x0,0x0,0x800000,0x0,0x0,0x80000,0x80000,0x0,0x200000,0x200000,0x200200,0x80000,0xa44200,0x40000,0x1000,0x4000,0x80000,0x0,0x0,0xa44200,0xa00200,0xa40200,0x80000,0x400000,0x10000,0x30053b0,0x30053b0,0x80000,0x800000,0x0,0x44000,0x10000,0x80000,0x200200,0x200000,0x200000,0x0,0x0,0x800000,0x0,0x0,0x13b0,0x0,0x0,0x200,0x80000,0x800000,0x0,0x4000200,0x0,0x0,0x200,0x80000,0x400000,0x400000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x90000000,0x90000000,0x0,0x60800000,0x60800000,0x0,0x0,0x0,0x0,0x0,0x0,0x30013b0,0x3000000,0x3000000,0x13b0,0x30013b0,0x1000,0x0,0x0,0x1000,0x11b0,0x200,0x111000,0x1b0,0x0,0x30013b0,0x80000,0x800000,0x4000,0x11000,0x0,0x10000,0x10000,0x453b0,0x200000,0x200000,0x200000,0x80000,0x400000,0x0,0x13b0,0x0,0x0,0x0,0x2013b0,0x30013b0,0x13b0,0x2413b0,0x13b0,0x80000,0x200,0x200,0x30013b0,0x1000,0x0,0x0,0x200000,0x200000,0x8000000,0x200000,0x200,0x80000,0x32053b0,0x80000,0x32053b0,0x240200,0x0,0x200200,0x240200,0x0,};
9677    }
 
9678  3 toggle private static void jj_la1_init_3() {
9679  3 jj_la1_3 = new int[] {0x0,0x0,0x10000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe000,0xffe000,0x0,0x1,0x2,0x200,0x400,0x100,0x0,0x0,0x0,0x8000000,0x8000000,0x1000,0x30,0x30,0x8c0,0x8c0,0x30,0x3c,0x0,0x0,0x0,0x0,0x0,0xc,0xc,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc,0x0,0x0,0x0,0x0,0xffe000,0xc,0x0,0x0,0x0,0x0,0xc,0x3c,0xc,0xc,0xc,0x0,0x0,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3c,0x0,0x3c,0x0,0x0,0x0,0x0,0x0,};
9680    }
9681    final private JJCalls[] jj_2_rtns = new JJCalls[54];
9682    private boolean jj_rescan = false;
9683    private int jj_gc = 0;
9684   
9685    /** Constructor with user supplied CharStream. */
 
9686  8945 toggle public JavaParser(CharStream stream) {
9687  8947 token_source = new JavaParserTokenManager(stream);
9688  8948 token = new Token();
9689  8946 token.next = jj_nt = token_source.getNextToken();
9690  8948 jj_gen = 0;
9691  1279551 for (int i = 0; i < 142; i++) jj_la1[i] = -1;
9692  492170 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9693    }
9694   
9695    /** Reinitialise. */
 
9696  0 toggle public void ReInit(CharStream stream) {
9697  0 token_source.ReInit(stream);
9698  0 token = new Token();
9699  0 token.next = jj_nt = token_source.getNextToken();
9700  0 jj_lookingAhead = false;
9701  0 jjtree.reset();
9702  0 jj_gen = 0;
9703  0 for (int i = 0; i < 142; i++) jj_la1[i] = -1;
9704  0 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9705    }
9706   
9707    /** Constructor with generated Token Manager. */
 
9708  0 toggle public JavaParser(JavaParserTokenManager tm) {
9709  0 token_source = tm;
9710  0 token = new Token();
9711  0 token.next = jj_nt = token_source.getNextToken();
9712  0 jj_gen = 0;
9713  0 for (int i = 0; i < 142; i++) jj_la1[i] = -1;
9714  0 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9715    }
9716   
9717    /** Reinitialise. */
 
9718  0 toggle public void ReInit(JavaParserTokenManager tm) {
9719  0 token_source = tm;
9720  0 token = new Token();
9721  0 token.next = jj_nt = token_source.getNextToken();
9722  0 jjtree.reset();
9723  0 jj_gen = 0;
9724  0 for (int i = 0; i < 142; i++) jj_la1[i] = -1;
9725  0 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
9726    }
9727   
 
9728  1891544 toggle private Token jj_consume_token(int kind) throws ParseException {
9729  1891770 Token oldToken = token;
9730  ? if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
9731  1072732 else jj_nt = jj_nt.next = token_source.getNextToken();
9732  1891695 if (token.kind == kind) {
9733  1891586 jj_gen++;
9734  1891355 if (++jj_gc > 100) {
9735  15492 jj_gc = 0;
9736  852055 for (int i = 0; i < jj_2_rtns.length; i++) {
9737  836561 JJCalls c = jj_2_rtns[i];
9738  1685780 while (c != null) {
9739  849227 if (c.gen < jj_gen) c.first = null;
9740  849227 c = c.next;
9741    }
9742    }
9743    }
9744  1891387 return token;
9745    }
9746  3 jj_nt = token;
9747  3 token = oldToken;
9748  3 jj_kind = kind;
9749  3 throw generateParseException();
9750    }
9751   
 
9752    static private final class LookaheadSuccess extends java.lang.Error { }
9753    final private LookaheadSuccess jj_ls = new LookaheadSuccess();
 
9754  41616185 toggle private boolean jj_scan_token(int kind) {
9755  41624225 if (jj_scanpos == jj_lastpos) {
9756  4617039 jj_la--;
9757  4617005 if (jj_scanpos.next == null) {
9758  818699 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
9759    } else {
9760  3798241 jj_lastpos = jj_scanpos = jj_scanpos.next;
9761    }
9762    } else {
9763  37005411 jj_scanpos = jj_scanpos.next;
9764    }
9765  41611856 if (jj_rescan) {
9766  489 int i = 0; Token tok = token;
9767  1482 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
9768  489 if (tok != null) jj_add_error_token(kind, i);
9769    }
9770  41615633 if (jj_scanpos.kind != kind) return true;
9771  2328802 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
9772  1812893 return false;
9773    }
9774   
9775   
9776    /** Get the next Token. */
 
9777  0 toggle final public Token getNextToken() {
9778  0 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
9779  0 else jj_nt = jj_nt.next = token_source.getNextToken();
9780  0 jj_gen++;
9781  0 return token;
9782    }
9783   
9784    /** Get the specific Token. */
 
9785  1236713 toggle final public Token getToken(int index) {
9786  1236884 Token t = jj_lookingAhead ? jj_scanpos : token;
9787  2473753 for (int i = 0; i < index; i++) {
9788  1236780 if (t.next != null) t = t.next;
9789  270 else t = t.next = token_source.getNextToken();
9790    }
9791  1236744 return t;
9792    }
9793   
9794    private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
9795    private int[] jj_expentry;
9796    private int jj_kind = -1;
9797    private int[] jj_lasttokens = new int[100];
9798    private int jj_endpos;
9799   
 
9800  177 toggle private void jj_add_error_token(int kind, int pos) {
9801  0 if (pos >= 100) return;
9802  177 if (pos == jj_endpos + 1) {
9803  3 jj_lasttokens[jj_endpos++] = kind;
9804  174 } else if (jj_endpos != 0) {
9805  174 jj_expentry = new int[jj_endpos];
9806  348 for (int i = 0; i < jj_endpos; i++) {
9807  174 jj_expentry[i] = jj_lasttokens[i];
9808    }
9809  2436 jj_entries_loop: for (java.util.Iterator it = jj_expentries.iterator(); it.hasNext();) {
9810  2262 int[] oldentry = (int[])(it.next());
9811  2262 if (oldentry.length == jj_expentry.length) {
9812  2262 for (int i = 0; i < jj_expentry.length; i++) {
9813  2262 if (oldentry[i] != jj_expentry[i]) {
9814  2262 continue jj_entries_loop;
9815    }
9816    }
9817  0 jj_expentries.add(jj_expentry);
9818  0 break jj_entries_loop;
9819    }
9820    }
9821  174 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
9822    }
9823    }
9824   
9825    /** Generate ParseException. */
 
9826  3 toggle public ParseException generateParseException() {
9827  3 jj_expentries.clear();
9828  3 boolean[] la1tokens = new boolean[126];
9829  3 if (jj_kind >= 0) {
9830  3 la1tokens[jj_kind] = true;
9831  3 jj_kind = -1;
9832    }
9833  429 for (int i = 0; i < 142; i++) {
9834  426 if (jj_la1[i] == jj_gen) {
9835  99 for (int j = 0; j < 32; j++) {
9836  96 if ((jj_la1_0[i] & (1<<j)) != 0) {
9837  0 la1tokens[j] = true;
9838    }
9839  96 if ((jj_la1_1[i] & (1<<j)) != 0) {
9840  0 la1tokens[32+j] = true;
9841    }
9842  96 if ((jj_la1_2[i] & (1<<j)) != 0) {
9843  3 la1tokens[64+j] = true;
9844    }
9845  96 if ((jj_la1_3[i] & (1<<j)) != 0) {
9846  33 la1tokens[96+j] = true;
9847    }
9848    }
9849    }
9850    }
9851  381 for (int i = 0; i < 126; i++) {
9852  378 if (la1tokens[i]) {
9853  39 jj_expentry = new int[1];
9854  39 jj_expentry[0] = i;
9855  39 jj_expentries.add(jj_expentry);
9856    }
9857    }
9858  3 jj_endpos = 0;
9859  3 jj_rescan_token();
9860  3 jj_add_error_token(0, 0);
9861  3 int[][] exptokseq = new int[jj_expentries.size()][];
9862  42 for (int i = 0; i < jj_expentries.size(); i++) {
9863  39 exptokseq[i] = jj_expentries.get(i);
9864    }
9865  3 return new ParseException(token, exptokseq, tokenImage);
9866    }
9867   
9868    /** Enable tracing. */
 
9869  0 toggle final public void enable_tracing() {
9870    }
9871   
9872    /** Disable tracing. */
 
9873  0 toggle final public void disable_tracing() {
9874    }
9875   
 
9876  3 toggle private void jj_rescan_token() {
9877  3 jj_rescan = true;
9878  165 for (int i = 0; i < 54; i++) {
9879  162 try {
9880  162 JJCalls p = jj_2_rtns[i];
9881  162 do {
9882  162 if (p.gen > jj_gen) {
9883  6 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
9884  6 switch (i) {
9885  0 case 0: jj_3_1(); break;
9886  0 case 1: jj_3_2(); break;
9887  0 case 2: jj_3_3(); break;
9888  0 case 3: jj_3_4(); break;
9889  0 case 4: jj_3_5(); break;
9890  0 case 5: jj_3_6(); break;
9891  0 case 6: jj_3_7(); break;
9892  0 case 7: jj_3_8(); break;
9893  0 case 8: jj_3_9(); break;
9894  0 case 9: jj_3_10(); break;
9895  0 case 10: jj_3_11(); break;
9896  0 case 11: jj_3_12(); break;
9897  0 case 12: jj_3_13(); break;
9898  0 case 13: jj_3_14(); break;
9899  0 case 14: jj_3_15(); break;
9900  0 case 15: jj_3_16(); break;
9901  0 case 16: jj_3_17(); break;
9902  0 case 17: jj_3_18(); break;
9903  0 case 18: jj_3_19(); break;
9904  0 case 19: jj_3_20(); break;
9905  0 case 20: jj_3_21(); break;
9906  0 case 21: jj_3_22(); break;
9907  0 case 22: jj_3_23(); break;
9908  0 case 23: jj_3_24(); break;
9909  0 case 24: jj_3_25(); break;
9910  0 case 25: jj_3_26(); break;
9911  0 case 26: jj_3_27(); break;
9912  0 case 27: jj_3_28(); break;
9913  3 case 28: jj_3_29(); break;
9914  0 case 29: jj_3_30(); break;
9915  0 case 30: jj_3_31(); break;
9916  0 case 31: jj_3_32(); break;
9917  0 case 32: jj_3_33(); break;
9918  0 case 33: jj_3_34(); break;
9919  0 case 34: jj_3_35(); break;
9920  0 case 35: jj_3_36(); break;
9921  0 case 36: jj_3_37(); break;
9922  0 case 37: jj_3_38(); break;
9923  0 case 38: jj_3_39(); break;
9924  0 case 39: jj_3_40(); break;
9925  0 case 40: jj_3_41(); break;
9926  0 case 41: jj_3_42(); break;
9927  0 case 42: jj_3_43(); break;
9928  3 case 43: jj_3_44(); break;
9929  0 case 44: jj_3_45(); break;
9930  0 case 45: jj_3_46(); break;
9931  0 case 46: jj_3_47(); break;
9932  0 case 47: jj_3_48(); break;
9933  0 case 48: jj_3_49(); break;
9934  0 case 49: jj_3_50(); break;
9935  0 case 50: jj_3_51(); break;
9936  0 case 51: jj_3_52(); break;
9937  0 case 52: jj_3_53(); break;
9938  0 case 53: jj_3_54(); break;
9939    }
9940    }
9941  162 p = p.next;
9942  162 } while (p != null);
9943    } catch(LookaheadSuccess ls) { }
9944    }
9945  3 jj_rescan = false;
9946    }
9947   
 
9948  3201418 toggle private void jj_save(int index, int xla) {
9949  3201818 JJCalls p = jj_2_rtns[index];
9950  3213755 while (p.gen > jj_gen) {
9951  13770 if (p.next == null) { p = p.next = new JJCalls(); break; }
9952  11733 p = p.next;
9953    }
9954  3201565 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
9955    }
9956   
 
9957    static final class JJCalls {
9958    int gen;
9959    Token first;
9960    int arg;
9961    JJCalls next;
9962    }
9963   
9964    }
 
CloverReport generated by Clover Code Coverage v2.5.1
Tue May 1 2012 12:33:49 CEST.		   Clover: Open Source License registered to pmd .